< Summary

Class:GDX.Tables.StableTable
Assembly:GDX
File(s):D:/BuildAgent/work/GDX-Documentation/Projects/GDX_Development/Packages/com.dotbunny.gdx/GDX/Tables/StableTable.cs
Covered lines:0
Uncovered lines:1208
Coverable lines:1208
Total lines:1866
Line coverage:0% (0 of 1208)
Covered branches:0
Total branches:0
Covered methods:0
Total methods:169
Method coverage:0% (0 of 169)

Coverage History

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity NPath complexity Sequence coverage
StableTable()0%2100%
StableTable()0%2100%
GetDataVersion()0%2100%
GetColumnCount()0%2100%
GetRowCount()0%2100%
GetDisplayName()0%2100%
SetDisplayName(...)0%2100%
GetFlag(...)0%2100%
SetFlag(...)0%2100%
GetAllRowDescriptions()0%20400%
GetRowDescription(...)0%12300%
GetRowDescription(...)0%2100%
SetAllRowDescriptionsOrder(...)0%2100%
GetColumnDescription(...)0%30500%
GetColumnDescription(...)0%2100%
SetAllColumnDescriptionsOrder(...)0%2100%
GetAllColumnDescriptions()0%12300%
AssertColumnIDValid(...)0%20400%
AssertRowIDValid(...)0%30500%
SetColumnName(...)0%2100%
GetColumnName(...)0%2100%
SetRowName(...)0%2100%
GetRowName(...)0%2100%
GetRowNameRef(...)0%2100%
GetColumnNameRef(...)0%2100%
AddRow(...)0%2401500%
AddRows(...)0%4202000%
AddRows(...)0%4202000%
RemoveRow(...)0%6200%
AddColumn(...)0%9923100%
RemoveColumn(...)0%9303000%
SetString(...)0%2100%
SetBool(...)0%2100%
SetChar(...)0%2100%
SetSByte(...)0%2100%
SetByte(...)0%2100%
SetShort(...)0%2100%
SetUShort(...)0%2100%
SetInt(...)0%2100%
SetUInt(...)0%2100%
SetLong(...)0%2100%
SetULong(...)0%2100%
SetFloat(...)0%2100%
SetDouble(...)0%2100%
SetVector2(...)0%2100%
SetVector3(...)0%2100%
SetVector4(...)0%2100%
SetVector2Int(...)0%2100%
SetVector3Int(...)0%2100%
SetQuaternion(...)0%2100%
SetRect(...)0%2100%
SetRectInt(...)0%2100%
SetColor(...)0%2100%
SetLayerMask(...)0%2100%
SetBounds(...)0%2100%
SetBoundsInt(...)0%2100%
SetHash128(...)0%2100%
SetGradient(...)0%2100%
SetAnimationCurve(...)0%2100%
SetObject(...)0%2100%
SetTypeNameForObjectColumn[T](...)0%2100%
GetString(...)0%2100%
GetBool(...)0%2100%
GetChar(...)0%2100%
GetSByte(...)0%2100%
GetByte(...)0%2100%
GetShort(...)0%2100%
GetUShort(...)0%2100%
GetInt(...)0%2100%
GetUInt(...)0%2100%
GetLong(...)0%2100%
GetULong(...)0%2100%
GetFloat(...)0%2100%
GetDouble(...)0%2100%
GetVector2(...)0%2100%
GetVector3(...)0%2100%
GetVector4(...)0%2100%
GetVector2Int(...)0%2100%
GetVector3Int(...)0%2100%
GetQuaternion(...)0%2100%
GetRect(...)0%2100%
GetRectInt(...)0%2100%
GetColor(...)0%2100%
GetLayerMask(...)0%2100%
GetBounds(...)0%2100%
GetBoundsInt(...)0%2100%
GetHash128(...)0%2100%
GetGradient(...)0%2100%
GetAnimationCurve(...)0%2100%
GetObject(...)0%2100%
GetStringRef(...)0%2100%
GetBoolRef(...)0%2100%
GetCharRef(...)0%2100%
GetSbyteRef(...)0%2100%
GetByteRef(...)0%2100%
GetShortRef(...)0%2100%
GetUshortRef(...)0%2100%
GetIntRef(...)0%2100%
GetUintRef(...)0%2100%
GetLongRef(...)0%2100%
GetUlongRef(...)0%2100%
GetFloatRef(...)0%2100%
GetDoubleRef(...)0%2100%
GetVector2Ref(...)0%2100%
GetVector3Ref(...)0%2100%
GetVector4Ref(...)0%2100%
GetVector2IntRef(...)0%2100%
GetVector3IntRef(...)0%2100%
GetQuaternionRef(...)0%2100%
GetRectRef(...)0%2100%
GetRectIntRef(...)0%2100%
GetColorRef(...)0%2100%
GetLayerMaskRef(...)0%2100%
GetBoundsRef(...)0%2100%
GetBoundsIntRef(...)0%2100%
GetHash128Ref(...)0%2100%
GetGradientRef(...)0%2100%
GetAnimationCurveRef(...)0%2100%
GetObjectRef(...)0%2100%
GetStringColumn(...)0%2100%
GetBoolColumn(...)0%2100%
GetCharColumn(...)0%2100%
GetSbyteColumn(...)0%2100%
GetByteColumn(...)0%2100%
GetShortColumn(...)0%2100%
GetUshortColumn(...)0%2100%
GetIntColumn(...)0%2100%
GetUintColumn(...)0%2100%
GetLongColumn(...)0%2100%
GetUlongColumn(...)0%2100%
GetFloatColumn(...)0%2100%
GetDoubleColumn(...)0%2100%
GetVector2Column(...)0%2100%
GetVector3Column(...)0%2100%
GetVector4Column(...)0%2100%
GetVector2IntColumn(...)0%2100%
GetVector3IntColumn(...)0%2100%
GetQuaternionColumn(...)0%2100%
GetRectColumn(...)0%2100%
GetRectIntColumn(...)0%2100%
GetColorColumn(...)0%2100%
GetLayerMaskColumn(...)0%2100%
GetBoundsColumn(...)0%2100%
GetBoundsIntColumn(...)0%2100%
GetHash128Column(...)0%2100%
GetGradientColumn(...)0%2100%
GetAnimationCurveColumn(...)0%2100%
GetObjectColumn(...)0%2100%
SetColumnOrder(...)0%20400%
SetAllColumnOrders(...)0%6200%
SetRowOrder(...)0%20400%
SetAllRowOrders(...)0%6200%
ReSortRows[T](...)0%30500%
AddTypeNameEntryForUnityObjectColumn()0%12300%
RemoveTypeNameEntryForUnityObjectColumn(...)0%12300%
AssertObjectColumnIDValid(...)0%6200%
AddColumnInternal[T](...)0%4622100%
RemoveColumnInternal[T](...)0%12300%
InsertRowsOfTypeInternal[T](...)0%42600%
DeleteRowsOfTypeInternal[T](...)0%30500%
GetCellRef[T](...)0%2100%
GetCell[T](...)0%2100%
SetCell[T](...)0%2100%
GetColumn[T](...)0%2100%
SetRowOrderForColumns[T](...)0%56700%
AssertSortedColumnsArgValid(...)0%20400%
AssertColumnSortOrderValid(...)0%12300%
AssertRowSortOrderValid(...)0%12300%
AssertSortRowsArgValid(...)0%20400%

File(s)

D:/BuildAgent/work/GDX-Documentation/Projects/GDX_Development/Packages/com.dotbunny.gdx/GDX/Tables/StableTable.cs

#LineLine coverage
 1// Copyright (c) 2020-2023 dotBunny Inc.
 2// dotBunny licenses this file to you under the BSL-1.0 license.
 3// See the LICENSE file in the project root for more information.
 4
 5using System;
 6using GDX.Collections;
 7using UnityEngine;
 8using Object = UnityEngine.Object;
 9
 10namespace GDX.Tables
 11{
 12    [CreateAssetMenu(menuName = "GDX/Stable Table", fileName = "GDXStableTable")]
 13    [Serializable]
 14    public class StableTable : TableBase
 15    {
 016        internal static string UnityObjectString = typeof(Object).AssemblyQualifiedName;
 17
 018        [SerializeField] internal string DisplayName = "GDXStableTable";
 19
 20        [SerializeField] internal ArrayHolder<string>[] AllStringColumns;
 21        [SerializeField] internal ArrayHolder<bool>[] AllBoolColumns;
 22        [SerializeField] internal ArrayHolder<char>[] AllCharColumns;
 23        [SerializeField] internal ArrayHolder<sbyte>[] AllSbyteColumns;
 24        [SerializeField] internal ArrayHolder<byte>[] AllByteColumns;
 25        [SerializeField] internal ArrayHolder<short>[] AllShortColumns;
 26        [SerializeField] internal ArrayHolder<ushort>[] AllUshortColumns;
 27        [SerializeField] internal ArrayHolder<int>[] AllIntColumns;
 28        [SerializeField] internal ArrayHolder<uint>[] AllUintColumns;
 29        [SerializeField] internal ArrayHolder<long>[] AllLongColumns;
 30        [SerializeField] internal ArrayHolder<ulong>[] AllUlongColumns;
 31        [SerializeField] internal ArrayHolder<float>[] AllFloatColumns;
 32        [SerializeField] internal ArrayHolder<double>[] AllDoubleColumns;
 33        [SerializeField] internal ArrayHolder<Vector2>[] AllVector2Columns;
 34        [SerializeField] internal ArrayHolder<Vector3>[] AllVector3Columns;
 35        [SerializeField] internal ArrayHolder<Vector4>[] AllVector4Columns;
 36        [SerializeField] internal ArrayHolder<Vector2Int>[] AllVector2IntColumns;
 37        [SerializeField] internal ArrayHolder<Vector3Int>[] AllVector3IntColumns;
 38        [SerializeField] internal ArrayHolder<Quaternion>[] AllQuaternionColumns;
 39        [SerializeField] internal ArrayHolder<Rect>[] AllRectColumns;
 40        [SerializeField] internal ArrayHolder<RectInt>[] AllRectIntColumns;
 41        [SerializeField] internal ArrayHolder<Color>[] AllColorColumns;
 42        [SerializeField] internal ArrayHolder<LayerMask>[] AllLayerMaskColumns;
 43        [SerializeField] internal ArrayHolder<Bounds>[] AllBoundsColumns;
 44        [SerializeField] internal ArrayHolder<BoundsInt>[] AllBoundsIntColumns;
 45        [SerializeField] internal ArrayHolder<Hash128>[] AllHash128Columns;
 46        [SerializeField] internal ArrayHolder<Gradient>[] AllGradientColumns;
 47        [SerializeField] internal ArrayHolder<AnimationCurve>[] AllAnimationCurveColumns;
 48        [SerializeField] internal ArrayHolder<Object>[] AllObjectRefColumns;
 49        [SerializeField] internal string[] AllObjectRefTypeNames;
 50
 51        [SerializeField]
 052        internal ArrayHolder<string>[]
 53            AllColumnNames =
 54                new ArrayHolder<string>[Serializable
 55                    .SerializableTypesCount]; // Contains the name of each column of each type. Ordered by Serializable.
 56
 57        [SerializeField] internal int[] RowIDToDenseIndexMap;
 58        [SerializeField] internal int[] RowDenseIndexToIDMap;
 59        [SerializeField] internal string[] RowNames;
 60        [SerializeField] internal int RowEntriesFreeListHead;
 61
 62        [SerializeField] internal int RowCount;
 63
 64        [SerializeField] internal ColumnEntry[] ColumnIDToDenseIndexMap;
 65        [SerializeField] internal int[] ColumnIDToSortOrderMap;
 66        [SerializeField] internal int[] SortedOrderToColumnIDMap;
 67
 68        // TODO move with other block
 69        [SerializeField]
 070        ArrayHolder<int>[] ColumnDenseIndexToIDMap = new ArrayHolder<int>[Serializable.SerializableTypesCount];
 71
 72        [SerializeField] internal int ColumnEntriesFreeListHead;
 73
 74        [SerializeField] internal int CombinedColumnCount;
 75
 076        [SerializeField] internal ulong DataVersion = 1;
 77
 78        [SerializeField] BitArray8 SettingsFlags;
 79
 80        public override ulong GetDataVersion()
 081        {
 082            return DataVersion;
 083        }
 84
 85        /// <inheritdoc />
 86        public override int GetColumnCount()
 087        {
 088            return CombinedColumnCount;
 089        }
 90
 91        /// <inheritdoc />
 92        public override int GetRowCount()
 093        {
 094            return RowCount;
 095        }
 96
 97        public override string GetDisplayName()
 098        {
 099            return DisplayName;
 0100        }
 101
 102        public override void SetDisplayName(string displayName)
 0103        {
 0104            DisplayName = displayName;
 0105        }
 106
 107        public override bool GetFlag(Flags flag)
 0108        {
 0109            return SettingsFlags[(byte)flag];
 0110        }
 111
 112        public override void SetFlag(Flags flag, bool toggle)
 0113        {
 0114            SettingsFlags[(byte)flag] = toggle;
 0115        }
 116
 117        public override RowDescription[] GetAllRowDescriptions()
 0118        {
 0119            if (CombinedColumnCount == 0 || RowCount == 0)
 0120            {
 0121                return null;
 122            }
 123
 0124            RowDescription[] returnArray = new RowDescription[RowCount];
 0125            string empty = string.Empty;
 0126            for (int i = 0; i < RowCount; i++)
 0127            {
 0128                returnArray[i].InternalIndex = RowDenseIndexToIDMap[i];
 0129                returnArray[i].Name = RowNames[i];
 0130            }
 131
 0132            return returnArray;
 0133        }
 134
 135        public override RowDescription GetRowDescription(string name)
 0136        {
 0137            for (int i = 0; i < RowCount; i++)
 0138            {
 0139                string nameAt = RowNames[i];
 140
 0141                if (nameAt == name)
 0142                {
 0143                    return new RowDescription { InternalIndex = RowDenseIndexToIDMap[i], Name = nameAt };
 144                }
 0145            }
 146
 0147            throw new ArgumentException("Row with name " + name + " does not exist in the table");
 0148        }
 149
 150        public override RowDescription GetRowDescription(int order)
 0151        {
 0152            return new RowDescription { InternalIndex = RowDenseIndexToIDMap[order], Name = RowNames[order] };
 0153        }
 154
 155        public override void SetAllRowDescriptionsOrder(RowDescription[] orderedRows)
 0156        {
 157            // TODO: @adam array coming in be in the new order, just use the internalIndex (stable to reorder inside her
 0158            throw new NotImplementedException();
 159        }
 160
 161        public override ColumnDescription GetColumnDescription(string name)
 0162        {
 0163            for (int i = 0; i < Serializable.SerializableTypesCount; i++)
 0164            {
 0165                string[] columnNames = AllColumnNames[i].TArray;
 166
 0167                if (columnNames != null)
 0168                {
 0169                    for (int j = 0; j < columnNames.Length; j++)
 0170                    {
 0171                        string nameAt = columnNames[j];
 172
 0173                        if (name == nameAt)
 0174                        {
 0175                            int columnID = ColumnDenseIndexToIDMap[i].TArray[j];
 176
 0177                            ref ColumnEntry columnEntry = ref ColumnIDToDenseIndexMap[columnID];
 0178                            return new ColumnDescription
 179                            {
 180                                InternalIndex = columnID, Name = nameAt, Type = columnEntry.ColumnType
 181                            };
 182                        }
 0183                    }
 0184                }
 0185            }
 186
 0187            throw new ArgumentException("Column with name " + name + " does not exist in the table");
 0188        }
 189
 190        public override ColumnDescription GetColumnDescription(int order)
 0191        {
 0192            int idAtOrderedIndex = SortedOrderToColumnIDMap[order];
 0193            ref ColumnEntry columnEntry = ref ColumnIDToDenseIndexMap[idAtOrderedIndex];
 194
 0195            string columnName = AllColumnNames[(int)columnEntry.ColumnType][columnEntry.ColumnDenseIndex];
 196
 0197            return new ColumnDescription
 198            {
 199                InternalIndex = idAtOrderedIndex, Name = columnName, Type = columnEntry.ColumnType
 200            };
 0201        }
 202
 203        public override void SetAllColumnDescriptionsOrder(ColumnDescription[] orderedColumns)
 0204        {
 205            // TODO: @adam array coming in be in the new order, just use the internalIndex (stable to reorder inside her
 0206            throw new NotImplementedException();
 207        }
 208
 209        /// <inheritdoc />
 210        public override ColumnDescription[] GetAllColumnDescriptions()
 0211        {
 0212            if (CombinedColumnCount == 0)
 0213            {
 0214                return null;
 215            }
 216
 0217            ColumnDescription[] returnArray = new ColumnDescription[CombinedColumnCount];
 218
 0219            for (int i = 0; i < CombinedColumnCount; i++)
 0220            {
 0221                int columnID = SortedOrderToColumnIDMap[i];
 0222                AssertColumnIDValid(columnID);
 0223                ref ColumnEntry entryForID = ref ColumnIDToDenseIndexMap[columnID];
 0224                ref ArrayHolder<string> nameColumnsForType = ref AllColumnNames[(int)entryForID.ColumnType];
 225
 0226                string name = nameColumnsForType[entryForID.ColumnDenseIndex];
 227
 0228                returnArray[i] = new ColumnDescription
 229                {
 230                    Name = name, InternalIndex = columnID, Type = entryForID.ColumnType
 231                };
 0232            }
 233
 0234            return returnArray;
 0235        }
 236
 237        internal void AssertColumnIDValid(int columnID)
 0238        {
 0239            if (columnID < 0 || columnID >= ColumnIDToDenseIndexMap.Length)
 0240            {
 0241                throw new ArgumentException("Invalid column outside valid ID range: " + columnID);
 242            }
 243
 0244            ref ColumnEntry columnEntry = ref ColumnIDToDenseIndexMap[columnID];
 245
 0246            if (columnEntry.ColumnType == Serializable.SerializableTypes.Invalid)
 0247            {
 0248                throw new ArgumentException("Invalid column pointing to deallocated entry: " + columnID);
 249            }
 0250        }
 251
 252        internal void AssertRowIDValid(int rowID)
 0253        {
 0254            if (rowID < 0 || rowID >= RowIDToDenseIndexMap.Length)
 0255            {
 0256                throw new ArgumentException("Invalid row outside valid ID range: " + rowID);
 257            }
 258
 0259            int rowIndex = RowIDToDenseIndexMap[rowID];
 260
 0261            if (rowIndex >= RowCount || rowIndex < 0)
 0262            {
 0263                throw new ArgumentException("Invalid row outside valid ID range: " + rowID);
 264            }
 0265        }
 266
 267        public override void SetColumnName(string columnName, int column)
 0268        {
 0269            AssertColumnIDValid(column);
 0270            ref ColumnEntry columnEntry = ref ColumnIDToDenseIndexMap[column];
 0271            AllColumnNames[(int)columnEntry.ColumnType][columnEntry.ColumnDenseIndex] = columnName;
 0272        }
 273
 274        public override string GetColumnName(int column)
 0275        {
 0276            AssertColumnIDValid(column);
 0277            ref ColumnEntry columnEntry = ref ColumnIDToDenseIndexMap[column];
 0278            return AllColumnNames[(int)columnEntry.ColumnType][columnEntry.ColumnDenseIndex];
 0279        }
 280
 281        public override void SetRowName(string rowName, int row)
 0282        {
 0283            AssertRowIDValid(row);
 0284            int rowDenseIndex = RowIDToDenseIndexMap[row];
 0285            RowNames[rowDenseIndex] = rowName;
 0286        }
 287
 288        public override string GetRowName(int row)
 0289        {
 0290            AssertRowIDValid(row);
 0291            int rowDenseIndex = RowIDToDenseIndexMap[row];
 0292            return RowNames[rowDenseIndex];
 0293        }
 294
 295        public ref string GetRowNameRef(int row)
 0296        {
 0297            AssertRowIDValid(row);
 0298            int rowDenseIndex = RowIDToDenseIndexMap[row];
 0299            return ref RowNames[rowDenseIndex];
 0300        }
 301
 302        public ref string GetColumnNameRef(int columnID)
 0303        {
 0304            AssertColumnIDValid(columnID);
 0305            ref ColumnEntry columnEntry = ref ColumnIDToDenseIndexMap[columnID];
 0306            return ref AllColumnNames[(int)columnEntry.ColumnType][columnEntry.ColumnDenseIndex];
 0307        }
 308
 309
 310        public override int AddRow(string rowName = null, int insertAtRowID = -1)
 0311        {
 0312            if (insertAtRowID >= 0)
 0313            {
 0314                AssertRowIDValid(insertAtRowID);
 0315            }
 316
 0317            int rowID = RowEntriesFreeListHead;
 0318            int rowIDToDenseIndexMapLength = RowIDToDenseIndexMap?.Length ?? 0;
 0319            if (rowID >= rowIDToDenseIndexMapLength)
 0320            {
 0321                int newSize = rowID * 2;
 0322                newSize = newSize == 0 ? 1 : newSize;
 0323                Array.Resize(ref RowIDToDenseIndexMap, newSize);
 0324                for (int i = rowID; i < newSize; i++)
 0325                {
 0326                    RowIDToDenseIndexMap[i] = i + 1;
 0327                }
 0328            }
 329
 0330            int denseIndexToIDMapLength = RowDenseIndexToIDMap?.Length ?? 0;
 0331            Array.Resize(ref RowDenseIndexToIDMap, denseIndexToIDMapLength + 1);
 0332            Array.Resize(ref RowNames, denseIndexToIDMapLength + 1);
 333
 0334            int insertAt = insertAtRowID < 0 ? RowCount : RowIDToDenseIndexMap[insertAtRowID];
 335
 0336            for (int i = denseIndexToIDMapLength; i > insertAt; i--)
 0337            {
 0338                int currentRowID = RowDenseIndexToIDMap[i - 1];
 0339                RowDenseIndexToIDMap[i] = currentRowID;
 340
 0341                RowIDToDenseIndexMap[currentRowID] = i;
 342
 0343                RowNames[i] = RowNames[i - 1];
 0344            }
 345
 0346            RowEntriesFreeListHead = RowIDToDenseIndexMap[rowID];
 0347            RowIDToDenseIndexMap[rowID] = insertAt;
 0348            RowDenseIndexToIDMap[insertAt] = rowID;
 0349            RowNames[insertAt] = rowName == null ? rowID.ToString() : rowName;
 350
 0351            InsertRowsOfTypeInternal(ref AllStringColumns, insertAt, 1);
 0352            InsertRowsOfTypeInternal(ref AllBoolColumns, insertAt, 1);
 0353            InsertRowsOfTypeInternal(ref AllCharColumns, insertAt, 1);
 0354            InsertRowsOfTypeInternal(ref AllSbyteColumns, insertAt, 1);
 0355            InsertRowsOfTypeInternal(ref AllByteColumns, insertAt, 1);
 0356            InsertRowsOfTypeInternal(ref AllShortColumns, insertAt, 1);
 0357            InsertRowsOfTypeInternal(ref AllUshortColumns, insertAt, 1);
 0358            InsertRowsOfTypeInternal(ref AllIntColumns, insertAt, 1);
 0359            InsertRowsOfTypeInternal(ref AllUintColumns, insertAt, 1);
 0360            InsertRowsOfTypeInternal(ref AllLongColumns, insertAt, 1);
 0361            InsertRowsOfTypeInternal(ref AllUlongColumns, insertAt, 1);
 0362            InsertRowsOfTypeInternal(ref AllFloatColumns, insertAt, 1);
 0363            InsertRowsOfTypeInternal(ref AllDoubleColumns, insertAt, 1);
 0364            InsertRowsOfTypeInternal(ref AllVector2Columns, insertAt, 1);
 0365            InsertRowsOfTypeInternal(ref AllVector3Columns, insertAt, 1);
 0366            InsertRowsOfTypeInternal(ref AllVector4Columns, insertAt, 1);
 0367            InsertRowsOfTypeInternal(ref AllVector2IntColumns, insertAt, 1);
 0368            InsertRowsOfTypeInternal(ref AllVector3IntColumns, insertAt, 1);
 0369            InsertRowsOfTypeInternal(ref AllQuaternionColumns, insertAt, 1);
 0370            InsertRowsOfTypeInternal(ref AllRectColumns, insertAt, 1);
 0371            InsertRowsOfTypeInternal(ref AllRectIntColumns, insertAt, 1);
 0372            InsertRowsOfTypeInternal(ref AllColorColumns, insertAt, 1);
 0373            InsertRowsOfTypeInternal(ref AllLayerMaskColumns, insertAt, 1);
 0374            InsertRowsOfTypeInternal(ref AllBoundsColumns, insertAt, 1);
 0375            InsertRowsOfTypeInternal(ref AllBoundsIntColumns, insertAt, 1);
 0376            InsertRowsOfTypeInternal(ref AllHash128Columns, insertAt, 1);
 0377            InsertRowsOfTypeInternal(ref AllGradientColumns, insertAt, 1);
 0378            InsertRowsOfTypeInternal(ref AllAnimationCurveColumns, insertAt, 1);
 0379            InsertRowsOfTypeInternal(ref AllObjectRefColumns, insertAt, 1);
 380
 0381            ++RowCount;
 0382            DataVersion++;
 383
 0384            return rowID;
 0385        }
 386
 387        public void AddRows(int numberOfNewRows, string[] rowNames = null, int insertAtRowID = -1)
 0388        {
 0389            if (insertAtRowID >= 0)
 0390            {
 0391                AssertRowIDValid(insertAtRowID);
 0392            }
 393
 0394            int rowIDToDenseIndexMapLength = RowIDToDenseIndexMap?.Length ?? 0;
 0395            int newCount = RowCount + numberOfNewRows;
 0396            if (newCount > rowIDToDenseIndexMapLength)
 0397            {
 0398                int newSize = newCount;
 0399                --newSize;
 0400                newSize |= newSize >> 1;
 0401                newSize |= newSize >> 2;
 0402                newSize |= newSize >> 4;
 0403                newSize |= newSize >> 8;
 0404                newSize |= newSize >> 16;
 0405                ++newSize;
 406
 0407                newSize = newSize == 0 ? 1 : newSize;
 0408                Array.Resize(ref RowIDToDenseIndexMap, newSize);
 0409                for (int i = rowIDToDenseIndexMapLength; i < newSize; i++)
 0410                {
 0411                    RowIDToDenseIndexMap[i] = i + 1;
 0412                }
 0413            }
 414
 0415            int denseIndexToIDMapLength = RowDenseIndexToIDMap?.Length ?? 0;
 0416            Array.Resize(ref RowDenseIndexToIDMap, denseIndexToIDMapLength + numberOfNewRows);
 0417            Array.Resize(ref rowNames, denseIndexToIDMapLength + numberOfNewRows);
 418
 0419            int insertAt = insertAtRowID < 0 ? RowCount : RowIDToDenseIndexMap[insertAtRowID];
 420
 0421            for (int i = denseIndexToIDMapLength; i > insertAt + numberOfNewRows - 1; i--)
 0422            {
 0423                int currentRowID = RowDenseIndexToIDMap[i - numberOfNewRows];
 0424                RowDenseIndexToIDMap[i] = currentRowID;
 425
 0426                RowIDToDenseIndexMap[currentRowID] = i;
 427
 0428                rowNames[i] = rowNames[i - numberOfNewRows];
 0429            }
 430
 0431            int freeListHead = RowEntriesFreeListHead;
 432
 0433            for (int i = 0; i < numberOfNewRows; i++)
 0434            {
 0435                int rowID = freeListHead;
 0436                freeListHead = RowIDToDenseIndexMap[rowID];
 0437                RowIDToDenseIndexMap[rowID] = insertAt + i;
 0438                RowDenseIndexToIDMap[insertAt + i] = rowID;
 0439            }
 440
 0441            int numberOfNewRowNames = rowNames?.Length ?? 0;
 0442            string emptyString = string.Empty;
 0443            for (int i = 0; i < numberOfNewRowNames; i++)
 0444            {
 0445                string currentRowName = rowNames[i];
 0446                int rowIDAt = RowDenseIndexToIDMap[insertAt + i];
 0447                rowNames[insertAt + i] = currentRowName == null ? rowIDAt.ToString() : currentRowName;
 0448            }
 449
 0450            for (int i = numberOfNewRowNames; i < numberOfNewRows; i++)
 0451            {
 0452                int rowIDAt = RowDenseIndexToIDMap[insertAt + i];
 0453                rowNames[insertAt + i] = rowIDAt.ToString();
 0454            }
 455
 0456            RowEntriesFreeListHead = freeListHead;
 457
 0458            InsertRowsOfTypeInternal(ref AllStringColumns, insertAt, numberOfNewRows);
 0459            InsertRowsOfTypeInternal(ref AllBoolColumns, insertAt, numberOfNewRows);
 0460            InsertRowsOfTypeInternal(ref AllCharColumns, insertAt, numberOfNewRows);
 0461            InsertRowsOfTypeInternal(ref AllSbyteColumns, insertAt, numberOfNewRows);
 0462            InsertRowsOfTypeInternal(ref AllByteColumns, insertAt, numberOfNewRows);
 0463            InsertRowsOfTypeInternal(ref AllShortColumns, insertAt, numberOfNewRows);
 0464            InsertRowsOfTypeInternal(ref AllUshortColumns, insertAt, numberOfNewRows);
 0465            InsertRowsOfTypeInternal(ref AllIntColumns, insertAt, numberOfNewRows);
 0466            InsertRowsOfTypeInternal(ref AllUintColumns, insertAt, numberOfNewRows);
 0467            InsertRowsOfTypeInternal(ref AllLongColumns, insertAt, numberOfNewRows);
 0468            InsertRowsOfTypeInternal(ref AllUlongColumns, insertAt, numberOfNewRows);
 0469            InsertRowsOfTypeInternal(ref AllFloatColumns, insertAt, numberOfNewRows);
 0470            InsertRowsOfTypeInternal(ref AllDoubleColumns, insertAt, numberOfNewRows);
 0471            InsertRowsOfTypeInternal(ref AllVector2Columns, insertAt, numberOfNewRows);
 0472            InsertRowsOfTypeInternal(ref AllVector3Columns, insertAt, numberOfNewRows);
 0473            InsertRowsOfTypeInternal(ref AllVector4Columns, insertAt, numberOfNewRows);
 0474            InsertRowsOfTypeInternal(ref AllVector2IntColumns, insertAt, numberOfNewRows);
 0475            InsertRowsOfTypeInternal(ref AllVector3IntColumns, insertAt, numberOfNewRows);
 0476            InsertRowsOfTypeInternal(ref AllQuaternionColumns, insertAt, numberOfNewRows);
 0477            InsertRowsOfTypeInternal(ref AllRectColumns, insertAt, numberOfNewRows);
 0478            InsertRowsOfTypeInternal(ref AllRectIntColumns, insertAt, numberOfNewRows);
 0479            InsertRowsOfTypeInternal(ref AllColorColumns, insertAt, numberOfNewRows);
 0480            InsertRowsOfTypeInternal(ref AllLayerMaskColumns, insertAt, numberOfNewRows);
 0481            InsertRowsOfTypeInternal(ref AllBoundsColumns, insertAt, numberOfNewRows);
 0482            InsertRowsOfTypeInternal(ref AllBoundsIntColumns, insertAt, numberOfNewRows);
 0483            InsertRowsOfTypeInternal(ref AllHash128Columns, insertAt, numberOfNewRows);
 0484            InsertRowsOfTypeInternal(ref AllGradientColumns, insertAt, numberOfNewRows);
 0485            InsertRowsOfTypeInternal(ref AllAnimationCurveColumns, insertAt, numberOfNewRows);
 0486            InsertRowsOfTypeInternal(ref AllObjectRefColumns, insertAt, numberOfNewRows);
 487
 0488            RowCount += numberOfNewRows;
 0489            DataVersion++;
 0490        }
 491
 492        public void AddRows(int numberOfNewRows, ref int[] rowIDs, string[] rowNames = null, int insertAtRowID = -1)
 0493        {
 0494            if (insertAtRowID >= 0)
 0495            {
 0496                AssertRowIDValid(insertAtRowID);
 0497            }
 498
 0499            int rowIDToDenseIndexMapLength = RowIDToDenseIndexMap?.Length ?? 0;
 0500            int newCount = RowCount + numberOfNewRows;
 0501            if (newCount > rowIDToDenseIndexMapLength)
 0502            {
 0503                int newSize = newCount;
 0504                --newSize;
 0505                newSize |= newSize >> 1;
 0506                newSize |= newSize >> 2;
 0507                newSize |= newSize >> 4;
 0508                newSize |= newSize >> 8;
 0509                newSize |= newSize >> 16;
 0510                ++newSize;
 511
 0512                newSize = newSize == 0 ? 1 : newSize;
 0513                Array.Resize(ref RowIDToDenseIndexMap, newSize);
 0514                for (int i = rowIDToDenseIndexMapLength; i < newSize; i++)
 0515                {
 0516                    RowIDToDenseIndexMap[i] = i + 1;
 0517                }
 0518            }
 519
 0520            int denseIndexToIDMapLength = RowDenseIndexToIDMap?.Length ?? 0;
 0521            Array.Resize(ref RowDenseIndexToIDMap, denseIndexToIDMapLength + numberOfNewRows);
 522
 0523            int insertAt = insertAtRowID < 0 ? RowCount : RowIDToDenseIndexMap[insertAtRowID];
 524
 0525            for (int i = denseIndexToIDMapLength; i > insertAt + numberOfNewRows - 1; i--)
 0526            {
 0527                int currentRowID = RowDenseIndexToIDMap[i - numberOfNewRows];
 0528                RowDenseIndexToIDMap[i] = currentRowID;
 529
 0530                RowIDToDenseIndexMap[currentRowID] = i;
 531
 0532                rowNames[i] = rowNames[i - numberOfNewRows];
 0533            }
 534
 0535            int freeListHead = RowEntriesFreeListHead;
 536
 0537            for (int i = 0; i < numberOfNewRows; i++)
 0538            {
 0539                int rowID = freeListHead;
 0540                freeListHead = RowIDToDenseIndexMap[rowID];
 0541                RowIDToDenseIndexMap[rowID] = insertAt + i;
 0542                RowDenseIndexToIDMap[insertAt + i] = rowID;
 0543                rowIDs[i] = rowID;
 0544            }
 545
 0546            int numberOfNewRowNames = rowNames?.Length ?? 0;
 0547            for (int i = 0; i < numberOfNewRowNames; i++)
 0548            {
 0549                string currentRowName = rowNames[i];
 0550                int rowIDAt = RowDenseIndexToIDMap[insertAt + i];
 0551                rowNames[insertAt + i] = currentRowName == null ? rowIDAt.ToString() : currentRowName;
 0552            }
 553
 0554            for (int i = numberOfNewRowNames; i < numberOfNewRows; i++)
 0555            {
 0556                int rowIDAt = RowDenseIndexToIDMap[insertAt + i];
 0557                rowNames[insertAt + i] = rowIDAt.ToString();
 0558            }
 559
 0560            RowEntriesFreeListHead = freeListHead;
 561
 0562            InsertRowsOfTypeInternal(ref AllStringColumns, insertAt, numberOfNewRows);
 0563            InsertRowsOfTypeInternal(ref AllBoolColumns, insertAt, numberOfNewRows);
 0564            InsertRowsOfTypeInternal(ref AllCharColumns, insertAt, numberOfNewRows);
 0565            InsertRowsOfTypeInternal(ref AllSbyteColumns, insertAt, numberOfNewRows);
 0566            InsertRowsOfTypeInternal(ref AllByteColumns, insertAt, numberOfNewRows);
 0567            InsertRowsOfTypeInternal(ref AllShortColumns, insertAt, numberOfNewRows);
 0568            InsertRowsOfTypeInternal(ref AllUshortColumns, insertAt, numberOfNewRows);
 0569            InsertRowsOfTypeInternal(ref AllIntColumns, insertAt, numberOfNewRows);
 0570            InsertRowsOfTypeInternal(ref AllUintColumns, insertAt, numberOfNewRows);
 0571            InsertRowsOfTypeInternal(ref AllLongColumns, insertAt, numberOfNewRows);
 0572            InsertRowsOfTypeInternal(ref AllUlongColumns, insertAt, numberOfNewRows);
 0573            InsertRowsOfTypeInternal(ref AllFloatColumns, insertAt, numberOfNewRows);
 0574            InsertRowsOfTypeInternal(ref AllDoubleColumns, insertAt, numberOfNewRows);
 0575            InsertRowsOfTypeInternal(ref AllVector2Columns, insertAt, numberOfNewRows);
 0576            InsertRowsOfTypeInternal(ref AllVector3Columns, insertAt, numberOfNewRows);
 0577            InsertRowsOfTypeInternal(ref AllVector4Columns, insertAt, numberOfNewRows);
 0578            InsertRowsOfTypeInternal(ref AllVector2IntColumns, insertAt, numberOfNewRows);
 0579            InsertRowsOfTypeInternal(ref AllVector3IntColumns, insertAt, numberOfNewRows);
 0580            InsertRowsOfTypeInternal(ref AllQuaternionColumns, insertAt, numberOfNewRows);
 0581            InsertRowsOfTypeInternal(ref AllRectColumns, insertAt, numberOfNewRows);
 0582            InsertRowsOfTypeInternal(ref AllRectIntColumns, insertAt, numberOfNewRows);
 0583            InsertRowsOfTypeInternal(ref AllColorColumns, insertAt, numberOfNewRows);
 0584            InsertRowsOfTypeInternal(ref AllLayerMaskColumns, insertAt, numberOfNewRows);
 0585            InsertRowsOfTypeInternal(ref AllBoundsColumns, insertAt, numberOfNewRows);
 0586            InsertRowsOfTypeInternal(ref AllBoundsIntColumns, insertAt, numberOfNewRows);
 0587            InsertRowsOfTypeInternal(ref AllHash128Columns, insertAt, numberOfNewRows);
 0588            InsertRowsOfTypeInternal(ref AllGradientColumns, insertAt, numberOfNewRows);
 0589            InsertRowsOfTypeInternal(ref AllAnimationCurveColumns, insertAt, numberOfNewRows);
 0590            InsertRowsOfTypeInternal(ref AllObjectRefColumns, insertAt, numberOfNewRows);
 591
 0592            RowCount += numberOfNewRows;
 0593            DataVersion++;
 0594        }
 595
 596        public override void RemoveRow(int rowID)
 0597        {
 0598            AssertRowIDValid(rowID);
 0599            int rowDenseIndex = RowIDToDenseIndexMap[rowID];
 0600            for (int i = rowDenseIndex + 1; i < RowCount; i++)
 0601            {
 0602                int currentRowID = RowDenseIndexToIDMap[i];
 0603                RowIDToDenseIndexMap[currentRowID] = i - 1;
 0604                RowDenseIndexToIDMap[i - 1] = currentRowID;
 0605                RowNames[i - 1] = RowNames[i];
 0606            }
 607
 0608            RowIDToDenseIndexMap[rowID] = RowEntriesFreeListHead;
 0609            RowEntriesFreeListHead = rowID;
 0610            Array.Resize(ref RowDenseIndexToIDMap, RowCount - 1);
 0611            Array.Resize(ref RowNames, RowCount - 1);
 612
 0613            DeleteRowsOfTypeInternal(ref AllStringColumns, rowID, 1);
 0614            DeleteRowsOfTypeInternal(ref AllBoolColumns, rowID, 1);
 0615            DeleteRowsOfTypeInternal(ref AllCharColumns, rowID, 1);
 0616            DeleteRowsOfTypeInternal(ref AllSbyteColumns, rowID, 1);
 0617            DeleteRowsOfTypeInternal(ref AllByteColumns, rowID, 1);
 0618            DeleteRowsOfTypeInternal(ref AllShortColumns, rowID, 1);
 0619            DeleteRowsOfTypeInternal(ref AllUshortColumns, rowID, 1);
 0620            DeleteRowsOfTypeInternal(ref AllIntColumns, rowID, 1);
 0621            DeleteRowsOfTypeInternal(ref AllUintColumns, rowID, 1);
 0622            DeleteRowsOfTypeInternal(ref AllLongColumns, rowID, 1);
 0623            DeleteRowsOfTypeInternal(ref AllUlongColumns, rowID, 1);
 0624            DeleteRowsOfTypeInternal(ref AllFloatColumns, rowID, 1);
 0625            DeleteRowsOfTypeInternal(ref AllDoubleColumns, rowID, 1);
 0626            DeleteRowsOfTypeInternal(ref AllVector2Columns, rowID, 1);
 0627            DeleteRowsOfTypeInternal(ref AllVector3Columns, rowID, 1);
 0628            DeleteRowsOfTypeInternal(ref AllVector4Columns, rowID, 1);
 0629            DeleteRowsOfTypeInternal(ref AllVector2IntColumns, rowID, 1);
 0630            DeleteRowsOfTypeInternal(ref AllVector3IntColumns, rowID, 1);
 0631            DeleteRowsOfTypeInternal(ref AllQuaternionColumns, rowID, 1);
 0632            DeleteRowsOfTypeInternal(ref AllRectColumns, rowID, 1);
 0633            DeleteRowsOfTypeInternal(ref AllRectIntColumns, rowID, 1);
 0634            DeleteRowsOfTypeInternal(ref AllColorColumns, rowID, 1);
 0635            DeleteRowsOfTypeInternal(ref AllLayerMaskColumns, rowID, 1);
 0636            DeleteRowsOfTypeInternal(ref AllBoundsColumns, rowID, 1);
 0637            DeleteRowsOfTypeInternal(ref AllBoundsIntColumns, rowID, 1);
 0638            DeleteRowsOfTypeInternal(ref AllHash128Columns, rowID, 1);
 0639            DeleteRowsOfTypeInternal(ref AllGradientColumns, rowID, 1);
 0640            DeleteRowsOfTypeInternal(ref AllAnimationCurveColumns, rowID, 1);
 0641            DeleteRowsOfTypeInternal(ref AllObjectRefColumns, rowID, 1);
 642
 0643            --RowCount;
 0644            DataVersion++;
 0645        }
 646
 647        public override int AddColumn(Serializable.SerializableTypes columnType, string columnName,
 648            int insertAtColumnID = -1)
 0649        {
 0650            switch (columnType)
 651            {
 652                case Serializable.SerializableTypes.String:
 0653                    return AddColumnInternal(columnName, ref AllStringColumns, Serializable.SerializableTypes.String,
 654                        insertAtColumnID);
 655                case Serializable.SerializableTypes.Char:
 0656                    return AddColumnInternal(columnName, ref AllCharColumns, Serializable.SerializableTypes.Char,
 657                        insertAtColumnID);
 658                case Serializable.SerializableTypes.Bool:
 0659                    return AddColumnInternal(columnName, ref AllBoolColumns, Serializable.SerializableTypes.Bool,
 660                        insertAtColumnID);
 661                case Serializable.SerializableTypes.SByte:
 0662                    return AddColumnInternal(columnName, ref AllSbyteColumns, Serializable.SerializableTypes.SByte,
 663                        insertAtColumnID);
 664                case Serializable.SerializableTypes.Byte:
 0665                    return AddColumnInternal(columnName, ref AllByteColumns, Serializable.SerializableTypes.Byte,
 666                        insertAtColumnID);
 667                case Serializable.SerializableTypes.Short:
 0668                    return AddColumnInternal(columnName, ref AllShortColumns, Serializable.SerializableTypes.Short,
 669                        insertAtColumnID);
 670                case Serializable.SerializableTypes.UShort:
 0671                    return AddColumnInternal(columnName, ref AllUshortColumns, Serializable.SerializableTypes.UShort,
 672                        insertAtColumnID);
 673                case Serializable.SerializableTypes.Int:
 0674                    return AddColumnInternal(columnName, ref AllIntColumns, Serializable.SerializableTypes.Int,
 675                        insertAtColumnID);
 676                case Serializable.SerializableTypes.UInt:
 0677                    return AddColumnInternal(columnName, ref AllUintColumns, Serializable.SerializableTypes.UInt,
 678                        insertAtColumnID);
 679                case Serializable.SerializableTypes.Long:
 0680                    return AddColumnInternal(columnName, ref AllLongColumns, Serializable.SerializableTypes.Long,
 681                        insertAtColumnID);
 682                case Serializable.SerializableTypes.ULong:
 0683                    return AddColumnInternal(columnName, ref AllUlongColumns, Serializable.SerializableTypes.ULong,
 684                        insertAtColumnID);
 685                case Serializable.SerializableTypes.Float:
 0686                    return AddColumnInternal(columnName, ref AllFloatColumns, Serializable.SerializableTypes.Float,
 687                        insertAtColumnID);
 688                case Serializable.SerializableTypes.Double:
 0689                    return AddColumnInternal(columnName, ref AllDoubleColumns, Serializable.SerializableTypes.Double,
 690                        insertAtColumnID);
 691                case Serializable.SerializableTypes.Vector2:
 0692                    return AddColumnInternal(columnName, ref AllVector2Columns, Serializable.SerializableTypes.Vector2,
 693                        insertAtColumnID);
 694                case Serializable.SerializableTypes.Vector3:
 0695                    return AddColumnInternal(columnName, ref AllVector3Columns, Serializable.SerializableTypes.Vector3,
 696                        insertAtColumnID);
 697                case Serializable.SerializableTypes.Vector4:
 0698                    return AddColumnInternal(columnName, ref AllVector4Columns, Serializable.SerializableTypes.Vector4,
 699                        insertAtColumnID);
 700                case Serializable.SerializableTypes.Vector2Int:
 0701                    return AddColumnInternal(columnName, ref AllVector2IntColumns,
 702                        Serializable.SerializableTypes.Vector2Int, insertAtColumnID);
 703                case Serializable.SerializableTypes.Vector3Int:
 0704                    return AddColumnInternal(columnName, ref AllVector3IntColumns,
 705                        Serializable.SerializableTypes.Vector3Int, insertAtColumnID);
 706                case Serializable.SerializableTypes.Quaternion:
 0707                    return AddColumnInternal(columnName, ref AllQuaternionColumns,
 708                        Serializable.SerializableTypes.Quaternion, insertAtColumnID);
 709                case Serializable.SerializableTypes.Rect:
 0710                    return AddColumnInternal(columnName, ref AllRectColumns, Serializable.SerializableTypes.Rect,
 711                        insertAtColumnID);
 712                case Serializable.SerializableTypes.RectInt:
 0713                    return AddColumnInternal(columnName, ref AllRectIntColumns, Serializable.SerializableTypes.RectInt,
 714                        insertAtColumnID);
 715                case Serializable.SerializableTypes.Color:
 0716                    return AddColumnInternal(columnName, ref AllColorColumns, Serializable.SerializableTypes.Color,
 717                        insertAtColumnID);
 718                case Serializable.SerializableTypes.LayerMask:
 0719                    return AddColumnInternal(columnName, ref AllLayerMaskColumns,
 720                        Serializable.SerializableTypes.LayerMask, insertAtColumnID);
 721                case Serializable.SerializableTypes.Bounds:
 0722                    return AddColumnInternal(columnName, ref AllBoundsColumns, Serializable.SerializableTypes.Bounds,
 723                        insertAtColumnID);
 724                case Serializable.SerializableTypes.BoundsInt:
 0725                    return AddColumnInternal(columnName, ref AllBoundsIntColumns,
 726                        Serializable.SerializableTypes.BoundsInt, insertAtColumnID);
 727                case Serializable.SerializableTypes.Hash128:
 0728                    return AddColumnInternal(columnName, ref AllHash128Columns, Serializable.SerializableTypes.Hash128,
 729                        insertAtColumnID);
 730                case Serializable.SerializableTypes.Gradient:
 0731                    return AddColumnInternal(columnName, ref AllGradientColumns,
 732                        Serializable.SerializableTypes.Gradient, insertAtColumnID);
 733                case Serializable.SerializableTypes.AnimationCurve:
 0734                    return AddColumnInternal(columnName, ref AllAnimationCurveColumns,
 735                        Serializable.SerializableTypes.AnimationCurve, insertAtColumnID);
 736                case Serializable.SerializableTypes.Object:
 0737                    return AddColumnInternal(columnName, ref AllObjectRefColumns, Serializable.SerializableTypes.Object,
 738                        insertAtColumnID);
 739            }
 740
 0741            return -1;
 0742        }
 743
 744        public override void RemoveColumn(Serializable.SerializableTypes columnType, int columnID)
 0745        {
 0746            switch (columnType)
 747            {
 748                case Serializable.SerializableTypes.String:
 0749                    RemoveColumnInternal(ref AllStringColumns, Serializable.SerializableTypes.String, columnID);
 0750                    break;
 751                case Serializable.SerializableTypes.Char:
 0752                    RemoveColumnInternal(ref AllCharColumns, Serializable.SerializableTypes.Char, columnID);
 0753                    break;
 754                case Serializable.SerializableTypes.Bool:
 0755                    RemoveColumnInternal(ref AllBoolColumns, Serializable.SerializableTypes.Bool, columnID);
 0756                    break;
 757                case Serializable.SerializableTypes.SByte:
 0758                    RemoveColumnInternal(ref AllSbyteColumns, Serializable.SerializableTypes.SByte, columnID);
 0759                    break;
 760                case Serializable.SerializableTypes.Byte:
 0761                    RemoveColumnInternal(ref AllByteColumns, Serializable.SerializableTypes.Byte, columnID);
 0762                    break;
 763                case Serializable.SerializableTypes.Short:
 0764                    RemoveColumnInternal(ref AllShortColumns, Serializable.SerializableTypes.Short, columnID);
 0765                    break;
 766                case Serializable.SerializableTypes.UShort:
 0767                    RemoveColumnInternal(ref AllUshortColumns, Serializable.SerializableTypes.UShort, columnID);
 0768                    break;
 769                case Serializable.SerializableTypes.Int:
 0770                    RemoveColumnInternal(ref AllIntColumns, Serializable.SerializableTypes.Int, columnID);
 0771                    break;
 772                case Serializable.SerializableTypes.UInt:
 0773                    RemoveColumnInternal(ref AllUintColumns, Serializable.SerializableTypes.UInt, columnID);
 0774                    break;
 775                case Serializable.SerializableTypes.Long:
 0776                    RemoveColumnInternal(ref AllLongColumns, Serializable.SerializableTypes.Long, columnID);
 0777                    break;
 778                case Serializable.SerializableTypes.ULong:
 0779                    RemoveColumnInternal(ref AllUlongColumns, Serializable.SerializableTypes.ULong, columnID);
 0780                    break;
 781                case Serializable.SerializableTypes.Float:
 0782                    RemoveColumnInternal(ref AllFloatColumns, Serializable.SerializableTypes.Float, columnID);
 0783                    break;
 784                case Serializable.SerializableTypes.Double:
 0785                    RemoveColumnInternal(ref AllDoubleColumns, Serializable.SerializableTypes.Double, columnID);
 0786                    break;
 787                case Serializable.SerializableTypes.Vector2:
 0788                    RemoveColumnInternal(ref AllVector2Columns, Serializable.SerializableTypes.Vector2, columnID);
 0789                    break;
 790                case Serializable.SerializableTypes.Vector3:
 0791                    RemoveColumnInternal(ref AllVector3Columns, Serializable.SerializableTypes.Vector3, columnID);
 0792                    break;
 793                case Serializable.SerializableTypes.Vector4:
 0794                    RemoveColumnInternal(ref AllVector4Columns, Serializable.SerializableTypes.Vector4, columnID);
 0795                    break;
 796                case Serializable.SerializableTypes.Vector2Int:
 0797                    RemoveColumnInternal(ref AllVector2IntColumns, Serializable.SerializableTypes.Vector2Int, columnID);
 0798                    break;
 799                case Serializable.SerializableTypes.Vector3Int:
 0800                    RemoveColumnInternal(ref AllVector3IntColumns, Serializable.SerializableTypes.Vector3Int, columnID);
 0801                    break;
 802                case Serializable.SerializableTypes.Quaternion:
 0803                    RemoveColumnInternal(ref AllQuaternionColumns, Serializable.SerializableTypes.Quaternion, columnID);
 0804                    break;
 805                case Serializable.SerializableTypes.Rect:
 0806                    RemoveColumnInternal(ref AllRectColumns, Serializable.SerializableTypes.Rect, columnID);
 0807                    break;
 808                case Serializable.SerializableTypes.RectInt:
 0809                    RemoveColumnInternal(ref AllRectIntColumns, Serializable.SerializableTypes.RectInt, columnID);
 0810                    break;
 811                case Serializable.SerializableTypes.Color:
 0812                    RemoveColumnInternal(ref AllColorColumns, Serializable.SerializableTypes.Color, columnID);
 0813                    break;
 814                case Serializable.SerializableTypes.LayerMask:
 0815                    RemoveColumnInternal(ref AllLayerMaskColumns, Serializable.SerializableTypes.LayerMask, columnID);
 0816                    break;
 817                case Serializable.SerializableTypes.Bounds:
 0818                    RemoveColumnInternal(ref AllBoundsColumns, Serializable.SerializableTypes.Bounds, columnID);
 0819                    break;
 820                case Serializable.SerializableTypes.BoundsInt:
 0821                    RemoveColumnInternal(ref AllBoundsIntColumns, Serializable.SerializableTypes.BoundsInt, columnID);
 0822                    break;
 823                case Serializable.SerializableTypes.Hash128:
 0824                    RemoveColumnInternal(ref AllHash128Columns, Serializable.SerializableTypes.Hash128, columnID);
 0825                    break;
 826                case Serializable.SerializableTypes.Gradient:
 0827                    RemoveColumnInternal(ref AllGradientColumns, Serializable.SerializableTypes.Gradient, columnID);
 0828                    break;
 829                case Serializable.SerializableTypes.AnimationCurve:
 0830                    RemoveColumnInternal(ref AllAnimationCurveColumns, Serializable.SerializableTypes.AnimationCurve,
 831                        columnID);
 0832                    break;
 833                case Serializable.SerializableTypes.Object:
 0834                    RemoveColumnInternal(ref AllObjectRefColumns, Serializable.SerializableTypes.Object, columnID);
 0835                    break;
 836            }
 0837        }
 838
 839        // Set
 840
 841        public override ulong SetString(int row, int column, string value)
 0842        {
 0843            return SetCell(row, column, ref AllStringColumns, value);
 0844        }
 845
 846        public override ulong SetBool(int row, int column, bool value)
 0847        {
 0848            return SetCell(row, column, ref AllBoolColumns, value);
 0849        }
 850
 851        public override ulong SetChar(int row, int column, char value)
 0852        {
 0853            return SetCell(row, column, ref AllCharColumns, value);
 0854        }
 855
 856        public override ulong SetSByte(int row, int column, sbyte value)
 0857        {
 0858            return SetCell(row, column, ref AllSbyteColumns, value);
 0859        }
 860
 861        public override ulong SetByte(int row, int column, byte value)
 0862        {
 0863            return SetCell(row, column, ref AllByteColumns, value);
 0864        }
 865
 866        public override ulong SetShort(int row, int column, short value)
 0867        {
 0868            return SetCell(row, column, ref AllShortColumns, value);
 0869        }
 870
 871        public override ulong SetUShort(int row, int column, ushort value)
 0872        {
 0873            return SetCell(row, column, ref AllUshortColumns, value);
 0874        }
 875
 876        public override ulong SetInt(int row, int column, int value)
 0877        {
 0878            return SetCell(row, column, ref AllIntColumns, value);
 0879        }
 880
 881        public override ulong SetUInt(int row, int column, uint value)
 0882        {
 0883            return SetCell(row, column, ref AllUintColumns, value);
 0884        }
 885
 886        public override ulong SetLong(int row, int column, long value)
 0887        {
 0888            return SetCell(row, column, ref AllLongColumns, value);
 0889        }
 890
 891        public override ulong SetULong(int row, int column, ulong value)
 0892        {
 0893            return SetCell(row, column, ref AllUlongColumns, value);
 0894        }
 895
 896        public override ulong SetFloat(int row, int column, float value)
 0897        {
 0898            return SetCell(row, column, ref AllFloatColumns, value);
 0899        }
 900
 901        public override ulong SetDouble(int row, int column, double value)
 0902        {
 0903            return SetCell(row, column, ref AllDoubleColumns, value);
 0904        }
 905
 906        public override ulong SetVector2(int row, int column, Vector2 value)
 0907        {
 0908            return SetCell(row, column, ref AllVector2Columns, value);
 0909        }
 910
 911        public override ulong SetVector3(int row, int column, Vector3 value)
 0912        {
 0913            return SetCell(row, column, ref AllVector3Columns, value);
 0914        }
 915
 916        public override ulong SetVector4(int row, int column, Vector4 value)
 0917        {
 0918            return SetCell(row, column, ref AllVector4Columns, value);
 0919        }
 920
 921        public override ulong SetVector2Int(int row, int column, Vector2Int value)
 0922        {
 0923            return SetCell(row, column, ref AllVector2IntColumns, value);
 0924        }
 925
 926        public override ulong SetVector3Int(int row, int column, Vector3Int value)
 0927        {
 0928            return SetCell(row, column, ref AllVector3IntColumns, value);
 0929        }
 930
 931        public override ulong SetQuaternion(int row, int column, Quaternion value)
 0932        {
 0933            return SetCell(row, column, ref AllQuaternionColumns, value);
 0934        }
 935
 936        public override ulong SetRect(int row, int column, Rect value)
 0937        {
 0938            return SetCell(row, column, ref AllRectColumns, value);
 0939        }
 940
 941        public override ulong SetRectInt(int row, int column, RectInt value)
 0942        {
 0943            return SetCell(row, column, ref AllRectIntColumns, value);
 0944        }
 945
 946        public override ulong SetColor(int row, int column, Color value)
 0947        {
 0948            return SetCell(row, column, ref AllColorColumns, value);
 0949        }
 950
 951        public override ulong SetLayerMask(int row, int column, LayerMask value)
 0952        {
 0953            return SetCell(row, column, ref AllLayerMaskColumns, value);
 0954        }
 955
 956        public override ulong SetBounds(int row, int column, Bounds value)
 0957        {
 0958            return SetCell(row, column, ref AllBoundsColumns, value);
 0959        }
 960
 961        public override ulong SetBoundsInt(int row, int column, BoundsInt value)
 0962        {
 0963            return SetCell(row, column, ref AllBoundsIntColumns, value);
 0964        }
 965
 966        public override ulong SetHash128(int row, int column, Hash128 value)
 0967        {
 0968            return SetCell(row, column, ref AllHash128Columns, value);
 0969        }
 970
 971        public override ulong SetGradient(int row, int column, Gradient value)
 0972        {
 0973            return SetCell(row, column, ref AllGradientColumns, value);
 0974        }
 975
 976        public override ulong SetAnimationCurve(int row, int column, AnimationCurve value)
 0977        {
 0978            return SetCell(row, column, ref AllAnimationCurveColumns, value);
 0979        }
 980
 981        public override ulong SetObject(int row, int column, Object value)
 0982        {
 0983            return SetCell(row, column, ref AllObjectRefColumns, value);
 0984        }
 985
 986        public void SetTypeNameForObjectColumn<T>(int columnID) where T : Object
 0987        {
 0988            AssertObjectColumnIDValid(columnID);
 0989            int denseIndex = ColumnIDToDenseIndexMap[columnID].ColumnDenseIndex;
 0990            AllObjectRefTypeNames[denseIndex] = typeof(T).AssemblyQualifiedName;
 0991        }
 992
 993        // Get
 994        public override string GetString(int row, int column)
 0995        {
 0996            return GetCell(row, column, ref AllStringColumns);
 0997        }
 998
 999        public override bool GetBool(int row, int column)
 01000        {
 01001            return GetCell(row, column, ref AllBoolColumns);
 01002        }
 1003
 1004        public override char GetChar(int row, int column)
 01005        {
 01006            return GetCell(row, column, ref AllCharColumns);
 01007        }
 1008
 1009        public override sbyte GetSByte(int row, int column)
 01010        {
 01011            return GetCell(row, column, ref AllSbyteColumns);
 01012        }
 1013
 1014        public override byte GetByte(int row, int column)
 01015        {
 01016            return GetCell(row, column, ref AllByteColumns);
 01017        }
 1018
 1019        public override short GetShort(int row, int column)
 01020        {
 01021            return GetCell(row, column, ref AllShortColumns);
 01022        }
 1023
 1024        public override ushort GetUShort(int row, int column)
 01025        {
 01026            return GetCell(row, column, ref AllUshortColumns);
 01027        }
 1028
 1029        public override int GetInt(int row, int column)
 01030        {
 01031            return GetCell(row, column, ref AllIntColumns);
 01032        }
 1033
 1034        public override uint GetUInt(int row, int column)
 01035        {
 01036            return GetCell(row, column, ref AllUintColumns);
 01037        }
 1038
 1039        public override long GetLong(int row, int column)
 01040        {
 01041            return GetCell(row, column, ref AllLongColumns);
 01042        }
 1043
 1044        public override ulong GetULong(int row, int column)
 01045        {
 01046            return GetCell(row, column, ref AllUlongColumns);
 01047        }
 1048
 1049        public override float GetFloat(int row, int column)
 01050        {
 01051            return GetCell(row, column, ref AllFloatColumns);
 01052        }
 1053
 1054        public override double GetDouble(int row, int column)
 01055        {
 01056            return GetCell(row, column, ref AllDoubleColumns);
 01057        }
 1058
 1059        public override Vector2 GetVector2(int row, int column)
 01060        {
 01061            return GetCell(row, column, ref AllVector2Columns);
 01062        }
 1063
 1064        public override Vector3 GetVector3(int row, int column)
 01065        {
 01066            return GetCell(row, column, ref AllVector3Columns);
 01067        }
 1068
 1069        public override Vector4 GetVector4(int row, int column)
 01070        {
 01071            return GetCell(row, column, ref AllVector4Columns);
 01072        }
 1073
 1074        public override Vector2Int GetVector2Int(int row, int column)
 01075        {
 01076            return GetCell(row, column, ref AllVector2IntColumns);
 01077        }
 1078
 1079        public override Vector3Int GetVector3Int(int row, int column)
 01080        {
 01081            return GetCell(row, column, ref AllVector3IntColumns);
 01082        }
 1083
 1084        public override Quaternion GetQuaternion(int row, int column)
 01085        {
 01086            return GetCell(row, column, ref AllQuaternionColumns);
 01087        }
 1088
 1089        public override Rect GetRect(int row, int column)
 01090        {
 01091            return GetCell(row, column, ref AllRectColumns);
 01092        }
 1093
 1094        public override RectInt GetRectInt(int row, int column)
 01095        {
 01096            return GetCell(row, column, ref AllRectIntColumns);
 01097        }
 1098
 1099        public override Color GetColor(int row, int column)
 01100        {
 01101            return GetCell(row, column, ref AllColorColumns);
 01102        }
 1103
 1104        public override LayerMask GetLayerMask(int row, int column)
 01105        {
 01106            return GetCell(row, column, ref AllLayerMaskColumns);
 01107        }
 1108
 1109        public override Bounds GetBounds(int row, int column)
 01110        {
 01111            return GetCell(row, column, ref AllBoundsColumns);
 01112        }
 1113
 1114        public override BoundsInt GetBoundsInt(int row, int column)
 01115        {
 01116            return GetCell(row, column, ref AllBoundsIntColumns);
 01117        }
 1118
 1119        public override Hash128 GetHash128(int row, int column)
 01120        {
 01121            return GetCell(row, column, ref AllHash128Columns);
 01122        }
 1123
 1124        public override Gradient GetGradient(int row, int column)
 01125        {
 01126            return GetCell(row, column, ref AllGradientColumns);
 01127        }
 1128
 1129        public override AnimationCurve GetAnimationCurve(int row, int column)
 01130        {
 01131            return GetCell(row, column, ref AllAnimationCurveColumns);
 01132        }
 1133
 1134        public override Object GetObject(int row, int column)
 01135        {
 01136            return GetCell(row, column, ref AllObjectRefColumns);
 01137        }
 1138
 1139        // Get ref
 1140
 1141        public ref string GetStringRef(int row, int column)
 01142        {
 01143            return ref GetCellRef(row, column, ref AllStringColumns);
 01144        }
 1145
 1146        public ref bool GetBoolRef(int row, int column)
 01147        {
 01148            return ref GetCellRef(row, column, ref AllBoolColumns);
 01149        }
 1150
 1151        public ref char GetCharRef(int row, int column)
 01152        {
 01153            return ref GetCellRef(row, column, ref AllCharColumns);
 01154        }
 1155
 1156        public ref sbyte GetSbyteRef(int row, int column)
 01157        {
 01158            return ref GetCellRef(row, column, ref AllSbyteColumns);
 01159        }
 1160
 1161        public ref byte GetByteRef(int row, int columnID)
 01162        {
 01163            return ref GetCellRef(row, columnID, ref AllByteColumns);
 01164        }
 1165
 1166        public ref short GetShortRef(int row, int column)
 01167        {
 01168            return ref GetCellRef(row, column, ref AllShortColumns);
 01169        }
 1170
 1171        public ref ushort GetUshortRef(int row, int column)
 01172        {
 01173            return ref GetCellRef(row, column, ref AllUshortColumns);
 01174        }
 1175
 1176        public ref int GetIntRef(int row, int column)
 01177        {
 01178            return ref GetCellRef(row, column, ref AllIntColumns);
 01179        }
 1180
 1181        public ref uint GetUintRef(int row, int column)
 01182        {
 01183            return ref GetCellRef(row, column, ref AllUintColumns);
 01184        }
 1185
 1186        public ref long GetLongRef(int row, int column)
 01187        {
 01188            return ref GetCellRef(row, column, ref AllLongColumns);
 01189        }
 1190
 1191        public ref ulong GetUlongRef(int row, int column)
 01192        {
 01193            return ref GetCellRef(row, column, ref AllUlongColumns);
 01194        }
 1195
 1196        public ref float GetFloatRef(int row, int column)
 01197        {
 01198            return ref GetCellRef(row, column, ref AllFloatColumns);
 01199        }
 1200
 1201        public ref double GetDoubleRef(int row, int column)
 01202        {
 01203            return ref GetCellRef(row, column, ref AllDoubleColumns);
 01204        }
 1205
 1206        public ref Vector2 GetVector2Ref(int row, int column)
 01207        {
 01208            return ref GetCellRef(row, column, ref AllVector2Columns);
 01209        }
 1210
 1211        public ref Vector3 GetVector3Ref(int row, int column)
 01212        {
 01213            return ref GetCellRef(row, column, ref AllVector3Columns);
 01214        }
 1215
 1216        public ref Vector4 GetVector4Ref(int row, int column)
 01217        {
 01218            return ref GetCellRef(row, column, ref AllVector4Columns);
 01219        }
 1220
 1221        public ref Vector2Int GetVector2IntRef(int row, int column)
 01222        {
 01223            return ref GetCellRef(row, column, ref AllVector2IntColumns);
 01224        }
 1225
 1226        public ref Vector3Int GetVector3IntRef(int row, int column)
 01227        {
 01228            return ref GetCellRef(row, column, ref AllVector3IntColumns);
 01229        }
 1230
 1231        public ref Quaternion GetQuaternionRef(int row, int column)
 01232        {
 01233            return ref GetCellRef(row, column, ref AllQuaternionColumns);
 01234        }
 1235
 1236        public ref Rect GetRectRef(int row, int column)
 01237        {
 01238            return ref GetCellRef(row, column, ref AllRectColumns);
 01239        }
 1240
 1241        public ref RectInt GetRectIntRef(int row, int column)
 01242        {
 01243            return ref GetCellRef(row, column, ref AllRectIntColumns);
 01244        }
 1245
 1246        public ref Color GetColorRef(int row, int column)
 01247        {
 01248            return ref GetCellRef(row, column, ref AllColorColumns);
 01249        }
 1250
 1251        public ref LayerMask GetLayerMaskRef(int row, int column)
 01252        {
 01253            return ref GetCellRef(row, column, ref AllLayerMaskColumns);
 01254        }
 1255
 1256        public ref Bounds GetBoundsRef(int row, int column)
 01257        {
 01258            return ref GetCellRef(row, column, ref AllBoundsColumns);
 01259        }
 1260
 1261        public ref BoundsInt GetBoundsIntRef(int row, int column)
 01262        {
 01263            return ref GetCellRef(row, column, ref AllBoundsIntColumns);
 01264        }
 1265
 1266        public ref Hash128 GetHash128Ref(int row, int column)
 01267        {
 01268            return ref GetCellRef(row, column, ref AllHash128Columns);
 01269        }
 1270
 1271        public ref Gradient GetGradientRef(int row, int column)
 01272        {
 01273            return ref GetCellRef(row, column, ref AllGradientColumns);
 01274        }
 1275
 1276        public ref AnimationCurve GetAnimationCurveRef(int row, int column)
 01277        {
 01278            return ref GetCellRef(row, column, ref AllAnimationCurveColumns);
 01279        }
 1280
 1281        public ref Object GetObjectRef(int row, int column)
 01282        {
 01283            return ref GetCellRef(row, column, ref AllObjectRefColumns);
 01284        }
 1285
 1286        // Get Column
 1287
 1288        public string[] GetStringColumn(int column)
 01289        {
 01290            return GetColumn(column, ref AllStringColumns);
 01291        }
 1292
 1293        public bool[] GetBoolColumn(int column)
 01294        {
 01295            return GetColumn(column, ref AllBoolColumns);
 01296        }
 1297
 1298        public char[] GetCharColumn(int column)
 01299        {
 01300            return GetColumn(column, ref AllCharColumns);
 01301        }
 1302
 1303        public sbyte[] GetSbyteColumn(int column)
 01304        {
 01305            return GetColumn(column, ref AllSbyteColumns);
 01306        }
 1307
 1308        public byte[] GetByteColumn(int column)
 01309        {
 01310            return GetColumn(column, ref AllByteColumns);
 01311        }
 1312
 1313        public short[] GetShortColumn(int column)
 01314        {
 01315            return GetColumn(column, ref AllShortColumns);
 01316        }
 1317
 1318        public ushort[] GetUshortColumn(int column)
 01319        {
 01320            return GetColumn(column, ref AllUshortColumns);
 01321        }
 1322
 1323        public int[] GetIntColumn(int column)
 01324        {
 01325            return GetColumn(column, ref AllIntColumns);
 01326        }
 1327
 1328        public uint[] GetUintColumn(int column)
 01329        {
 01330            return GetColumn(column, ref AllUintColumns);
 01331        }
 1332
 1333        public long[] GetLongColumn(int column)
 01334        {
 01335            return GetColumn(column, ref AllLongColumns);
 01336        }
 1337
 1338        public ulong[] GetUlongColumn(int column)
 01339        {
 01340            return GetColumn(column, ref AllUlongColumns);
 01341        }
 1342
 1343        public float[] GetFloatColumn(int column)
 01344        {
 01345            return GetColumn(column, ref AllFloatColumns);
 01346        }
 1347
 1348        public double[] GetDoubleColumn(int column)
 01349        {
 01350            return GetColumn(column, ref AllDoubleColumns);
 01351        }
 1352
 1353        public Vector2[] GetVector2Column(int column)
 01354        {
 01355            return GetColumn(column, ref AllVector2Columns);
 01356        }
 1357
 1358        public Vector3[] GetVector3Column(int column)
 01359        {
 01360            return GetColumn(column, ref AllVector3Columns);
 01361        }
 1362
 1363        public Vector4[] GetVector4Column(int column)
 01364        {
 01365            return GetColumn(column, ref AllVector4Columns);
 01366        }
 1367
 1368        public Vector2Int[] GetVector2IntColumn(int column)
 01369        {
 01370            return GetColumn(column, ref AllVector2IntColumns);
 01371        }
 1372
 1373        public Vector3Int[] GetVector3IntColumn(int column)
 01374        {
 01375            return GetColumn(column, ref AllVector3IntColumns);
 01376        }
 1377
 1378        public Quaternion[] GetQuaternionColumn(int column)
 01379        {
 01380            return GetColumn(column, ref AllQuaternionColumns);
 01381        }
 1382
 1383        public Rect[] GetRectColumn(int column)
 01384        {
 01385            return GetColumn(column, ref AllRectColumns);
 01386        }
 1387
 1388        public RectInt[] GetRectIntColumn(int column)
 01389        {
 01390            return GetColumn(column, ref AllRectIntColumns);
 01391        }
 1392
 1393        public Color[] GetColorColumn(int column)
 01394        {
 01395            return GetColumn(column, ref AllColorColumns);
 01396        }
 1397
 1398        public LayerMask[] GetLayerMaskColumn(int column)
 01399        {
 01400            return GetColumn(column, ref AllLayerMaskColumns);
 01401        }
 1402
 1403        public Bounds[] GetBoundsColumn(int column)
 01404        {
 01405            return GetColumn(column, ref AllBoundsColumns);
 01406        }
 1407
 1408        public BoundsInt[] GetBoundsIntColumn(int column)
 01409        {
 01410            return GetColumn(column, ref AllBoundsIntColumns);
 01411        }
 1412
 1413        public Hash128[] GetHash128Column(int column)
 01414        {
 01415            return GetColumn(column, ref AllHash128Columns);
 01416        }
 1417
 1418        public Gradient[] GetGradientColumn(int column)
 01419        {
 01420            return GetColumn(column, ref AllGradientColumns);
 01421        }
 1422
 1423        public AnimationCurve[] GetAnimationCurveColumn(int column)
 01424        {
 01425            return GetColumn(column, ref AllAnimationCurveColumns);
 01426        }
 1427
 1428        public Object[] GetObjectColumn(int column)
 01429        {
 01430            return GetColumn(column, ref AllObjectRefColumns);
 01431        }
 1432
 1433        // SetOrder
 1434
 1435        public void SetColumnOrder(int columnID, int newSortOrder)
 01436        {
 01437            AssertColumnIDValid(columnID);
 01438            AssertColumnSortOrderValid(newSortOrder);
 01439            int oldSortOrder = ColumnIDToSortOrderMap[columnID];
 01440            int iterDirection = newSortOrder > oldSortOrder ? 1 : -1;
 01441            for (int i = oldSortOrder; i != newSortOrder; i += iterDirection)
 01442            {
 01443                int columnIDAt = SortedOrderToColumnIDMap[i + iterDirection];
 01444                ColumnIDToSortOrderMap[columnIDAt] = i;
 01445                SortedOrderToColumnIDMap[i] = SortedOrderToColumnIDMap[i + iterDirection];
 01446            }
 1447
 01448            SortedOrderToColumnIDMap[newSortOrder] = columnID;
 01449            ColumnIDToSortOrderMap[columnID] = newSortOrder;
 01450        }
 1451
 1452        public void SetAllColumnOrders(int[] sortedColumnIDs)
 01453        {
 01454            AssertSortedColumnsArgValid(sortedColumnIDs);
 01455            for (int i = 0; i < SortedOrderToColumnIDMap.Length; i++)
 01456            {
 01457                int columnID = sortedColumnIDs[i];
 01458                SortedOrderToColumnIDMap[i] = columnID;
 01459                ColumnIDToSortOrderMap[columnID] = i;
 01460            }
 01461        }
 1462
 1463        public void SetRowOrder(int rowID, int newSortOrder)
 01464        {
 01465            AssertRowIDValid(rowID);
 01466            AssertRowSortOrderValid(newSortOrder);
 1467
 01468            int oldSortOrder = RowIDToDenseIndexMap[rowID];
 01469            int iterDirection = newSortOrder > oldSortOrder ? 1 : -1;
 1470
 01471            for (int i = oldSortOrder; i != newSortOrder; i += iterDirection)
 01472            {
 01473                int rowIDAt = RowDenseIndexToIDMap[i + iterDirection];
 01474                RowIDToDenseIndexMap[rowIDAt] = i;
 01475                RowDenseIndexToIDMap[i] = RowDenseIndexToIDMap[i + iterDirection];
 01476            }
 1477
 01478            SetRowOrderForColumns(AllStringColumns, oldSortOrder, newSortOrder);
 01479            SetRowOrderForColumns(AllBoolColumns, oldSortOrder, newSortOrder);
 01480            SetRowOrderForColumns(AllCharColumns, oldSortOrder, newSortOrder);
 01481            SetRowOrderForColumns(AllSbyteColumns, oldSortOrder, newSortOrder);
 01482            SetRowOrderForColumns(AllByteColumns, oldSortOrder, newSortOrder);
 01483            SetRowOrderForColumns(AllShortColumns, oldSortOrder, newSortOrder);
 01484            SetRowOrderForColumns(AllUshortColumns, oldSortOrder, newSortOrder);
 01485            SetRowOrderForColumns(AllIntColumns, oldSortOrder, newSortOrder);
 01486            SetRowOrderForColumns(AllUintColumns, oldSortOrder, newSortOrder);
 01487            SetRowOrderForColumns(AllLongColumns, oldSortOrder, newSortOrder);
 01488            SetRowOrderForColumns(AllUlongColumns, oldSortOrder, newSortOrder);
 01489            SetRowOrderForColumns(AllFloatColumns, oldSortOrder, newSortOrder);
 01490            SetRowOrderForColumns(AllDoubleColumns, oldSortOrder, newSortOrder);
 01491            SetRowOrderForColumns(AllVector2Columns, oldSortOrder, newSortOrder);
 01492            SetRowOrderForColumns(AllVector3Columns, oldSortOrder, newSortOrder);
 01493            SetRowOrderForColumns(AllVector4Columns, oldSortOrder, newSortOrder);
 01494            SetRowOrderForColumns(AllVector2IntColumns, oldSortOrder, newSortOrder);
 01495            SetRowOrderForColumns(AllVector3IntColumns, oldSortOrder, newSortOrder);
 01496            SetRowOrderForColumns(AllQuaternionColumns, oldSortOrder, newSortOrder);
 01497            SetRowOrderForColumns(AllRectColumns, oldSortOrder, newSortOrder);
 01498            SetRowOrderForColumns(AllRectIntColumns, oldSortOrder, newSortOrder);
 01499            SetRowOrderForColumns(AllColorColumns, oldSortOrder, newSortOrder);
 01500            SetRowOrderForColumns(AllLayerMaskColumns, oldSortOrder, newSortOrder);
 01501            SetRowOrderForColumns(AllBoundsColumns, oldSortOrder, newSortOrder);
 01502            SetRowOrderForColumns(AllBoundsIntColumns, oldSortOrder, newSortOrder);
 01503            SetRowOrderForColumns(AllHash128Columns, oldSortOrder, newSortOrder);
 01504            SetRowOrderForColumns(AllGradientColumns, oldSortOrder, newSortOrder);
 01505            SetRowOrderForColumns(AllAnimationCurveColumns, oldSortOrder, newSortOrder);
 01506            SetRowOrderForColumns(AllObjectRefColumns, oldSortOrder, newSortOrder);
 01507        }
 1508
 1509        public void SetAllRowOrders(int[] sortedRowIDs)
 01510        {
 01511            AssertSortRowsArgValid(sortedRowIDs);
 1512
 01513            ReSortRows(AllStringColumns, sortedRowIDs);
 01514            ReSortRows(AllBoolColumns, sortedRowIDs);
 01515            ReSortRows(AllCharColumns, sortedRowIDs);
 01516            ReSortRows(AllSbyteColumns, sortedRowIDs);
 01517            ReSortRows(AllByteColumns, sortedRowIDs);
 01518            ReSortRows(AllShortColumns, sortedRowIDs);
 01519            ReSortRows(AllUshortColumns, sortedRowIDs);
 01520            ReSortRows(AllIntColumns, sortedRowIDs);
 01521            ReSortRows(AllUintColumns, sortedRowIDs);
 01522            ReSortRows(AllLongColumns, sortedRowIDs);
 01523            ReSortRows(AllUlongColumns, sortedRowIDs);
 01524            ReSortRows(AllFloatColumns, sortedRowIDs);
 01525            ReSortRows(AllDoubleColumns, sortedRowIDs);
 01526            ReSortRows(AllVector2Columns, sortedRowIDs);
 01527            ReSortRows(AllVector3Columns, sortedRowIDs);
 01528            ReSortRows(AllVector4Columns, sortedRowIDs);
 01529            ReSortRows(AllVector2IntColumns, sortedRowIDs);
 01530            ReSortRows(AllVector3IntColumns, sortedRowIDs);
 01531            ReSortRows(AllQuaternionColumns, sortedRowIDs);
 01532            ReSortRows(AllRectColumns, sortedRowIDs);
 01533            ReSortRows(AllRectIntColumns, sortedRowIDs);
 01534            ReSortRows(AllColorColumns, sortedRowIDs);
 01535            ReSortRows(AllLayerMaskColumns, sortedRowIDs);
 01536            ReSortRows(AllBoundsColumns, sortedRowIDs);
 01537            ReSortRows(AllBoundsIntColumns, sortedRowIDs);
 01538            ReSortRows(AllHash128Columns, sortedRowIDs);
 01539            ReSortRows(AllGradientColumns, sortedRowIDs);
 01540            ReSortRows(AllAnimationCurveColumns, sortedRowIDs);
 01541            ReSortRows(AllObjectRefColumns, sortedRowIDs);
 1542
 01543            for (int i = 0; i < sortedRowIDs.Length; i++)
 01544            {
 01545                int rowID = sortedRowIDs[i];
 01546                RowDenseIndexToIDMap[i] = rowID;
 01547                RowIDToDenseIndexMap[rowID] = i;
 01548            }
 01549        }
 1550
 1551        internal void ReSortRows<T>(ArrayHolder<T>[] columns, int[] sortedRowIDs)
 01552        {
 01553            int columnCount = columns?.Length ?? 0;
 01554            for (int i = 0; i < columnCount; i++)
 01555            {
 01556                T[] column = columns[i].TArray;
 01557                T[] newColumn = new T[column.Length];
 01558                for (int j = 0; j < sortedRowIDs.Length; j++)
 01559                {
 01560                    int rowID = sortedRowIDs[j];
 01561                    int oldRowIndex = RowIDToDenseIndexMap[rowID];
 1562
 01563                    newColumn[j] = column[oldRowIndex];
 01564                }
 1565
 01566                columns[i].TArray = newColumn;
 01567            }
 01568        }
 1569
 1570        // Internal
 1571
 1572        internal void AddTypeNameEntryForUnityObjectColumn()
 01573        {
 01574            int nameArrayLength = AllObjectRefTypeNames?.Length ?? 0;
 01575            Array.Resize(ref AllObjectRefTypeNames, nameArrayLength + 1);
 01576            AllObjectRefTypeNames[nameArrayLength] = UnityObjectString;
 01577        }
 1578
 1579        internal void RemoveTypeNameEntryForUnityObjectColumn(int columnDenseIndex)
 01580        {
 01581            int nameArrayLength = AllObjectRefTypeNames?.Length ?? 0;
 01582            AllObjectRefTypeNames[columnDenseIndex] = AllObjectRefTypeNames[nameArrayLength];
 01583            Array.Resize(ref AllObjectRefTypeNames, nameArrayLength - 1);
 01584        }
 1585
 1586        internal void AssertObjectColumnIDValid(int columnID)
 01587        {
 01588            AssertColumnIDValid(columnID);
 01589            if (ColumnIDToDenseIndexMap[columnID].ColumnType != Serializable.SerializableTypes.Object)
 01590            {
 01591                throw new ArgumentException("Column ID must correspond to a UnityEngine.Object column.");
 1592            }
 01593        }
 1594
 1595        internal int AddColumnInternal<T>(string columnName, ref ArrayHolder<T>[] allColumnsOfType,
 1596            Serializable.SerializableTypes typeIndex, int insertAtColumnID)
 01597        {
 01598            if (insertAtColumnID >= 0)
 01599            {
 01600                AssertColumnIDValid(insertAtColumnID);
 01601            }
 1602
 01603            int columnCount = allColumnsOfType?.Length ?? 0;
 01604            Array.Resize(ref allColumnsOfType, columnCount + 1);
 01605            allColumnsOfType[columnCount].TArray = new T[RowCount];
 1606
 01607            int columnID = ColumnEntriesFreeListHead;
 01608            string[] columnNamesForType = AllColumnNames[(int)typeIndex].TArray;
 01609            int columnNamesCount = columnNamesForType?.Length ?? 0;
 01610            Array.Resize(ref columnNamesForType, columnNamesCount + 1);
 01611            columnNamesForType[columnNamesCount] = columnName == null ? columnID.ToString() : columnName;
 01612            AllColumnNames[(int)typeIndex].TArray = columnNamesForType;
 1613
 1614
 01615            int columnIDToDenseIndexMapLength = ColumnIDToDenseIndexMap?.Length ?? 0;
 01616            if (columnID >= columnIDToDenseIndexMapLength)
 01617            {
 01618                int newSize = columnIDToDenseIndexMapLength * 2;
 01619                newSize = newSize == 0 ? 1 : newSize;
 01620                Array.Resize(ref ColumnIDToDenseIndexMap, newSize);
 01621                for (int i = columnIDToDenseIndexMapLength; i < newSize; i++)
 01622                {
 01623                    ref ColumnEntry entry = ref ColumnIDToDenseIndexMap[i];
 01624                    entry.ColumnDenseIndex = i + 1;
 01625                    entry.ColumnType = Serializable.SerializableTypes.Invalid;
 01626                }
 1627
 01628                Array.Resize(ref ColumnIDToSortOrderMap, newSize);
 01629                for (int i = columnIDToDenseIndexMapLength; i < newSize; i++)
 01630                {
 01631                    ColumnIDToSortOrderMap[i] = -1;
 01632                }
 01633            }
 1634
 01635            ColumnEntriesFreeListHead = ColumnIDToDenseIndexMap[columnID].ColumnDenseIndex;
 1636
 01637            ref int[] denseIndexToIDMap = ref ColumnDenseIndexToIDMap[(int)typeIndex].TArray;
 01638            int denseIndexToIDMapLength = denseIndexToIDMap?.Length ?? 0;
 01639            Array.Resize(ref denseIndexToIDMap, denseIndexToIDMapLength + 1);
 01640            denseIndexToIDMap[denseIndexToIDMapLength] = columnID;
 1641
 01642            ref ColumnEntry newEntry = ref ColumnIDToDenseIndexMap[columnID];
 01643            newEntry.ColumnDenseIndex = denseIndexToIDMapLength;
 01644            newEntry.ColumnType = typeIndex;
 1645
 01646            int insertAtSortedIndex =
 1647                insertAtColumnID < 0 ? CombinedColumnCount : ColumnIDToSortOrderMap[insertAtColumnID];
 01648            Array.Resize(ref SortedOrderToColumnIDMap, CombinedColumnCount + 1);
 01649            for (int i = CombinedColumnCount; i > insertAtSortedIndex; i--)
 01650            {
 01651                int currentColumnID = SortedOrderToColumnIDMap[i - 1];
 01652                SortedOrderToColumnIDMap[i] = currentColumnID;
 01653                ColumnIDToSortOrderMap[currentColumnID] = i;
 01654            }
 1655
 01656            if (typeIndex == Serializable.SerializableTypes.Object)
 01657            {
 01658                AddTypeNameEntryForUnityObjectColumn();
 01659            }
 1660
 01661            ColumnIDToSortOrderMap[columnID] = insertAtSortedIndex;
 01662            SortedOrderToColumnIDMap[insertAtSortedIndex] = columnID;
 1663
 01664            ++CombinedColumnCount;
 01665            DataVersion++;
 1666
 01667            return columnID;
 01668        }
 1669
 1670        internal void RemoveColumnInternal<T>(ref ArrayHolder<T>[] allColumnsOfType,
 1671            Serializable.SerializableTypes typeIndex, int columnID)
 01672        {
 01673            AssertColumnIDValid(columnID);
 01674            int columnLocation = ColumnIDToDenseIndexMap[columnID].ColumnDenseIndex;
 1675
 01676            int lastIndex = allColumnsOfType.Length - 1;
 01677            allColumnsOfType[columnLocation] = allColumnsOfType[lastIndex];
 01678            Array.Resize(ref allColumnsOfType, lastIndex);
 1679
 01680            ref string[] columnNamesOfType = ref AllColumnNames[(int)typeIndex].TArray;
 01681            columnNamesOfType[columnLocation] = columnNamesOfType[lastIndex];
 01682            Array.Resize(ref columnNamesOfType, lastIndex);
 1683
 01684            int columnOrder = ColumnIDToSortOrderMap[columnID];
 1685
 01686            ref int[] denseIndicesOfType = ref ColumnDenseIndexToIDMap[(int)typeIndex].TArray;
 01687            int sparseIndexToSwap = denseIndicesOfType[lastIndex];
 1688
 01689            ref ColumnEntry sparseIndexToFree = ref ColumnIDToDenseIndexMap[columnID];
 01690            sparseIndexToFree.ColumnType = Serializable.SerializableTypes.Invalid;
 01691            sparseIndexToFree.ColumnDenseIndex = ColumnEntriesFreeListHead;
 01692            ColumnEntriesFreeListHead = columnID;
 1693
 01694            ColumnIDToDenseIndexMap[sparseIndexToSwap].ColumnDenseIndex = columnLocation;
 01695            denseIndicesOfType[columnLocation] = sparseIndexToSwap;
 01696            Array.Resize(ref denseIndicesOfType, lastIndex);
 1697
 01698            if (typeIndex == Serializable.SerializableTypes.Object)
 01699            {
 01700                RemoveTypeNameEntryForUnityObjectColumn(columnLocation);
 01701            }
 1702
 01703            for (int i = columnOrder + 1; i < CombinedColumnCount; i++)
 01704            {
 01705                int currentColumnID = SortedOrderToColumnIDMap[i];
 01706                SortedOrderToColumnIDMap[i - 1] = currentColumnID;
 01707                ColumnIDToSortOrderMap[currentColumnID] = i - 1;
 01708            }
 1709
 01710            Array.Resize(ref SortedOrderToColumnIDMap, CombinedColumnCount - 1);
 1711
 01712            --CombinedColumnCount;
 01713            DataVersion++;
 01714        }
 1715
 1716        internal void InsertRowsOfTypeInternal<T>(ref ArrayHolder<T>[] allColumnsOfType, int insertAt,
 1717            int numberOfNewRows)
 01718        {
 01719            int columnCount = allColumnsOfType?.Length ?? 0;
 01720            for (int i = 0; i < columnCount; i++)
 01721            {
 01722                ref T[] rows = ref allColumnsOfType[i].TArray;
 01723                int newRowCount = RowCount + numberOfNewRows;
 01724                Array.Resize(ref rows, newRowCount);
 01725                for (int j = newRowCount - 1; j > insertAt + numberOfNewRows - 1; j--)
 01726                {
 01727                    rows[j] = rows[j - numberOfNewRows];
 01728                }
 1729
 01730                for (int j = 0; j < numberOfNewRows; j++)
 01731                {
 01732                    rows[insertAt + j] = default;
 01733                }
 01734            }
 01735        }
 1736
 1737        internal void DeleteRowsOfTypeInternal<T>(ref ArrayHolder<T>[] allColumnsOfType, int removeAt,
 1738            int numberOfRowsToDelete)
 01739        {
 01740            int columnCount = allColumnsOfType?.Length ?? 0;
 1741
 01742            for (int i = 0; i < columnCount; i++)
 01743            {
 01744                ref T[] rows = ref allColumnsOfType[i].TArray;
 01745                int newRowCount = RowCount - numberOfRowsToDelete;
 1746
 01747                for (int j = removeAt + numberOfRowsToDelete; j < RowCount; j++)
 01748                {
 01749                    rows[j - numberOfRowsToDelete] = rows[j];
 01750                }
 1751
 01752                Array.Resize(ref rows, newRowCount);
 01753            }
 01754        }
 1755
 1756        internal ref T GetCellRef<T>(int rowID, int columnID, ref ArrayHolder<T>[] allColumnsOfType)
 01757        {
 01758            AssertColumnIDValid(columnID);
 01759            AssertRowIDValid(rowID);
 01760            int column = ColumnIDToDenseIndexMap[columnID].ColumnDenseIndex;
 01761            int row = RowIDToDenseIndexMap[rowID];
 01762            return ref allColumnsOfType[column][row];
 01763        }
 1764
 1765        internal T GetCell<T>(int rowID, int columnID, ref ArrayHolder<T>[] allColumnsOfType)
 01766        {
 01767            AssertColumnIDValid(columnID);
 01768            AssertRowIDValid(rowID);
 01769            int column = ColumnIDToDenseIndexMap[columnID].ColumnDenseIndex;
 01770            int row = RowIDToDenseIndexMap[rowID];
 01771            return allColumnsOfType[column][row];
 01772        }
 1773
 1774        internal ulong SetCell<T>(int rowID, int columnID, ref ArrayHolder<T>[] allColumnsOfType, T value)
 01775        {
 01776            AssertColumnIDValid(columnID);
 01777            AssertRowIDValid(rowID);
 01778            int column = ColumnIDToDenseIndexMap[columnID].ColumnDenseIndex;
 01779            int row = RowIDToDenseIndexMap[rowID];
 01780            allColumnsOfType[column][row] = value;
 01781            DataVersion++;
 01782            return DataVersion;
 01783        }
 1784
 1785        internal T[] GetColumn<T>(int columnID, ref ArrayHolder<T>[] allColumnsOfType)
 01786        {
 01787            AssertColumnIDValid(columnID);
 01788            int column = ColumnIDToDenseIndexMap[columnID].ColumnDenseIndex;
 01789            return allColumnsOfType[column].TArray;
 01790        }
 1791
 1792        internal void SetRowOrderForColumns<T>(ArrayHolder<T>[] columns, int oldSortOrder, int newSortOrder)
 01793        {
 01794            int columnCount = columns?.Length ?? 0;
 01795            int iterDirection = newSortOrder > oldSortOrder ? 1 : -1;
 01796            for (int i = 0; i < columnCount; i++)
 01797            {
 01798                T[] column = columns[i].TArray;
 1799
 01800                for (int j = oldSortOrder; j != newSortOrder; j += iterDirection)
 01801                {
 01802                    column[j] = column[j + iterDirection];
 01803                }
 01804            }
 01805        }
 1806
 1807        internal void AssertSortedColumnsArgValid(int[] sortedColumnIDs)
 01808        {
 01809            if (sortedColumnIDs == null)
 01810            {
 01811                throw new ArgumentException("sortedColumnIDs array cannot be null.");
 1812            }
 1813
 01814            if (sortedColumnIDs.Length != SortedOrderToColumnIDMap.Length)
 01815            {
 01816                throw new ArgumentException("sortedColumnIDs array must be the same length as GetColumnCount.");
 1817            }
 1818
 01819            for (int i = 0; i < sortedColumnIDs.Length; i++)
 01820            {
 01821                AssertColumnIDValid(sortedColumnIDs[i]);
 01822            }
 01823        }
 1824
 1825        internal void AssertColumnSortOrderValid(int sortedOrder)
 01826        {
 01827            if (sortedOrder >= CombinedColumnCount || sortedOrder < 0)
 01828            {
 01829                throw new ArgumentException("Invalid column sort order argument: " + sortedOrder);
 1830            }
 01831        }
 1832
 1833        internal void AssertRowSortOrderValid(int sortedOrder)
 01834        {
 01835            if (sortedOrder >= RowCount || sortedOrder < 0)
 01836            {
 01837                throw new ArgumentException("Invalid row sort order argument: " + sortedOrder);
 1838            }
 01839        }
 1840
 1841        internal void AssertSortRowsArgValid(int[] sortedRowIDs)
 01842        {
 01843            if (sortedRowIDs == null)
 01844            {
 01845                throw new ArgumentException("sortedRowIDs array cannot be null.");
 1846            }
 1847
 01848            if (sortedRowIDs.Length != RowDenseIndexToIDMap.Length)
 01849            {
 01850                throw new ArgumentException("sortedRowIDs array must be the same length as GetRowCount.");
 1851            }
 1852
 01853            for (int i = 0; i < sortedRowIDs.Length; i++)
 01854            {
 01855                AssertRowIDValid(sortedRowIDs[i]);
 01856            }
 01857        }
 1858
 1859        [Serializable]
 1860        internal struct ColumnEntry
 1861        {
 1862            public Serializable.SerializableTypes ColumnType;
 1863            public int ColumnDenseIndex;
 1864        }
 1865    }
 1866}

Coverage by test methods





































































































































































































































































































































































































































































































































































































































































































Methods/Properties

StableTable()
StableTable()
GetDataVersion()
GetColumnCount()
GetRowCount()
GetDisplayName()
SetDisplayName(System.String)
GetFlag(GDX.Tables.TableBase/Flags)
SetFlag(GDX.Tables.TableBase/Flags, System.Boolean)
GetAllRowDescriptions()
GetRowDescription(System.String)
GetRowDescription(System.Int32)
SetAllRowDescriptionsOrder(GDX.Tables.TableBase/RowDescription[])
GetColumnDescription(System.String)
GetColumnDescription(System.Int32)
SetAllColumnDescriptionsOrder(GDX.Tables.TableBase/ColumnDescription[])
GetAllColumnDescriptions()
AssertColumnIDValid(System.Int32)
AssertRowIDValid(System.Int32)
SetColumnName(System.String, System.Int32)
GetColumnName(System.Int32)
SetRowName(System.String, System.Int32)
GetRowName(System.Int32)
GetRowNameRef(System.Int32)
GetColumnNameRef(System.Int32)
AddRow(System.String, System.Int32)
AddRows(System.Int32, System.String[], System.Int32)
AddRows(System.Int32, System.Int32[]&, System.String[], System.Int32)
RemoveRow(System.Int32)
AddColumn(GDX.Serializable/SerializableTypes, System.String, System.Int32)
RemoveColumn(GDX.Serializable/SerializableTypes, System.Int32)
SetString(System.Int32, System.Int32, System.String)
SetBool(System.Int32, System.Int32, System.Boolean)
SetChar(System.Int32, System.Int32, System.Char)
SetSByte(System.Int32, System.Int32, System.SByte)
SetByte(System.Int32, System.Int32, System.Byte)
SetShort(System.Int32, System.Int32, System.Int16)
SetUShort(System.Int32, System.Int32, System.UInt16)
SetInt(System.Int32, System.Int32, System.Int32)
SetUInt(System.Int32, System.Int32, System.UInt32)
SetLong(System.Int32, System.Int32, System.Int64)
SetULong(System.Int32, System.Int32, System.UInt64)
SetFloat(System.Int32, System.Int32, System.Single)
SetDouble(System.Int32, System.Int32, System.Double)
SetVector2(System.Int32, System.Int32, UnityEngine.Vector2)
SetVector3(System.Int32, System.Int32, UnityEngine.Vector3)
SetVector4(System.Int32, System.Int32, UnityEngine.Vector4)
SetVector2Int(System.Int32, System.Int32, UnityEngine.Vector2Int)
SetVector3Int(System.Int32, System.Int32, UnityEngine.Vector3Int)
SetQuaternion(System.Int32, System.Int32, UnityEngine.Quaternion)
SetRect(System.Int32, System.Int32, UnityEngine.Rect)
SetRectInt(System.Int32, System.Int32, UnityEngine.RectInt)
SetColor(System.Int32, System.Int32, UnityEngine.Color)
SetLayerMask(System.Int32, System.Int32, UnityEngine.LayerMask)
SetBounds(System.Int32, System.Int32, UnityEngine.Bounds)
SetBoundsInt(System.Int32, System.Int32, UnityEngine.BoundsInt)
SetHash128(System.Int32, System.Int32, UnityEngine.Hash128)
SetGradient(System.Int32, System.Int32, UnityEngine.Gradient)
SetAnimationCurve(System.Int32, System.Int32, UnityEngine.AnimationCurve)
SetObject(System.Int32, System.Int32, UnityEngine.Object)
SetTypeNameForObjectColumn[T](System.Int32)
GetString(System.Int32, System.Int32)
GetBool(System.Int32, System.Int32)
GetChar(System.Int32, System.Int32)
GetSByte(System.Int32, System.Int32)
GetByte(System.Int32, System.Int32)
GetShort(System.Int32, System.Int32)
GetUShort(System.Int32, System.Int32)
GetInt(System.Int32, System.Int32)
GetUInt(System.Int32, System.Int32)
GetLong(System.Int32, System.Int32)
GetULong(System.Int32, System.Int32)
GetFloat(System.Int32, System.Int32)
GetDouble(System.Int32, System.Int32)
GetVector2(System.Int32, System.Int32)
GetVector3(System.Int32, System.Int32)
GetVector4(System.Int32, System.Int32)
GetVector2Int(System.Int32, System.Int32)
GetVector3Int(System.Int32, System.Int32)
GetQuaternion(System.Int32, System.Int32)
GetRect(System.Int32, System.Int32)
GetRectInt(System.Int32, System.Int32)
GetColor(System.Int32, System.Int32)
GetLayerMask(System.Int32, System.Int32)
GetBounds(System.Int32, System.Int32)
GetBoundsInt(System.Int32, System.Int32)
GetHash128(System.Int32, System.Int32)
GetGradient(System.Int32, System.Int32)
GetAnimationCurve(System.Int32, System.Int32)
GetObject(System.Int32, System.Int32)
GetStringRef(System.Int32, System.Int32)
GetBoolRef(System.Int32, System.Int32)
GetCharRef(System.Int32, System.Int32)
GetSbyteRef(System.Int32, System.Int32)
GetByteRef(System.Int32, System.Int32)
GetShortRef(System.Int32, System.Int32)
GetUshortRef(System.Int32, System.Int32)
GetIntRef(System.Int32, System.Int32)
GetUintRef(System.Int32, System.Int32)
GetLongRef(System.Int32, System.Int32)
GetUlongRef(System.Int32, System.Int32)
GetFloatRef(System.Int32, System.Int32)
GetDoubleRef(System.Int32, System.Int32)
GetVector2Ref(System.Int32, System.Int32)
GetVector3Ref(System.Int32, System.Int32)
GetVector4Ref(System.Int32, System.Int32)
GetVector2IntRef(System.Int32, System.Int32)
GetVector3IntRef(System.Int32, System.Int32)
GetQuaternionRef(System.Int32, System.Int32)
GetRectRef(System.Int32, System.Int32)
GetRectIntRef(System.Int32, System.Int32)
GetColorRef(System.Int32, System.Int32)
GetLayerMaskRef(System.Int32, System.Int32)
GetBoundsRef(System.Int32, System.Int32)
GetBoundsIntRef(System.Int32, System.Int32)
GetHash128Ref(System.Int32, System.Int32)
GetGradientRef(System.Int32, System.Int32)
GetAnimationCurveRef(System.Int32, System.Int32)
GetObjectRef(System.Int32, System.Int32)
GetStringColumn(System.Int32)
GetBoolColumn(System.Int32)
GetCharColumn(System.Int32)
GetSbyteColumn(System.Int32)
GetByteColumn(System.Int32)
GetShortColumn(System.Int32)
GetUshortColumn(System.Int32)
GetIntColumn(System.Int32)
GetUintColumn(System.Int32)
GetLongColumn(System.Int32)
GetUlongColumn(System.Int32)
GetFloatColumn(System.Int32)
GetDoubleColumn(System.Int32)
GetVector2Column(System.Int32)
GetVector3Column(System.Int32)
GetVector4Column(System.Int32)
GetVector2IntColumn(System.Int32)
GetVector3IntColumn(System.Int32)
GetQuaternionColumn(System.Int32)
GetRectColumn(System.Int32)
GetRectIntColumn(System.Int32)
GetColorColumn(System.Int32)
GetLayerMaskColumn(System.Int32)
GetBoundsColumn(System.Int32)
GetBoundsIntColumn(System.Int32)
GetHash128Column(System.Int32)
GetGradientColumn(System.Int32)
GetAnimationCurveColumn(System.Int32)
GetObjectColumn(System.Int32)
SetColumnOrder(System.Int32, System.Int32)
SetAllColumnOrders(System.Int32[])
SetRowOrder(System.Int32, System.Int32)
SetAllRowOrders(System.Int32[])
ReSortRows[T](, System.Int32[])
AddTypeNameEntryForUnityObjectColumn()
RemoveTypeNameEntryForUnityObjectColumn(System.Int32)
AssertObjectColumnIDValid(System.Int32)
AddColumnInternal[T](System.String, , GDX.Serializable/SerializableTypes, System.Int32)
RemoveColumnInternal[T](, GDX.Serializable/SerializableTypes, System.Int32)
InsertRowsOfTypeInternal[T](, System.Int32, System.Int32)
DeleteRowsOfTypeInternal[T](, System.Int32, System.Int32)
GetCellRef[T](System.Int32, System.Int32, )
GetCell[T](System.Int32, System.Int32, )
SetCell[T](System.Int32, System.Int32, , T)
GetColumn[T](System.Int32, )
SetRowOrderForColumns[T](, System.Int32, System.Int32)
AssertSortedColumnsArgValid(System.Int32[])
AssertColumnSortOrderValid(System.Int32)
AssertRowSortOrderValid(System.Int32)
AssertSortRowsArgValid(System.Int32[])